gramio 0.0.26 → 0.0.27

package/dist/bot.d.ts

@@ -2,14 +2,14 @@ import { CallbackData } from "@gramio/callback-data";
 import type { Context, ContextType, MaybeArray, UpdateName } from "@gramio/contexts";
 import type { APIMethodParams, APIMethods, SetMyCommandsParams, TelegramBotCommand, TelegramReactionTypeEmojiEmoji, TelegramUser } from "@gramio/types";
 import { Plugin } from "./plugin";
-import type { BotOptions, DeriveDefinitions, ErrorDefinitions, Handler, Hooks, MaybePromise } from "./types";
+import type { BotOptions, DeriveDefinitions, ErrorDefinitions, Handler, Hooks, MaybePromise, SuppressedAPIMethods } from "./types";
 import { Updates } from "./updates";
 export declare class Bot<Errors extends ErrorDefinitions = {}, Derives extends DeriveDefinitions = DeriveDefinitions> {
     /** @internal */
     __Derives: Derives;
     readonly options: BotOptions;
     info: TelegramUser | undefined;
-    readonly api: APIMethods;
+    readonly api: SuppressedAPIMethods;
     private lazyloadPlugins;
     private dependencies;
     private errorsDefinitions;
@@ -86,6 +86,16 @@ export declare class Bot<Errors extends ErrorDefinitions = {}, Derives extends D
     callbackQuery<Trigger extends CallbackData | string | RegExp>(trigger: Trigger, handler: (context: Omit<ContextType<typeof this, "callback_query">, "data"> & Derives["global"] & Derives["callback_query"] & {
         queryData: Trigger extends CallbackData ? ReturnType<Trigger["unpack"]> : RegExpMatchArray | null;
     }) => unknown): this;
+    chosenInlineResult<Ctx = ContextType<typeof this, "chosen_inline_result"> & Derives["global"] & Derives["chosen_inline_result"]>(trigger: RegExp | string | ((context: Ctx) => boolean), handler: (context: Ctx & {
+        args: RegExpMatchArray | null;
+    }) => unknown): this;
+    inlineQuery<Ctx = ContextType<typeof this, "inline_query"> & Derives["global"] & Derives["inline_query"]>(trigger: RegExp | string | ((context: Ctx) => boolean), handler: (context: Ctx & {
+        args: RegExpMatchArray | null;
+    }) => unknown, options?: {
+        onResult?: (context: ContextType<Bot, "chosen_inline_result"> & Derives["global"] & Derives["chosen_inline_result"] & {
+            args: 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;
     }) => unknown): this;

package/dist/bot.js

@@ -149,7 +149,9 @@ let Bot = (() => {
                 const err = new errors_1.TelegramError(data, method, params);
                 // @ts-expect-error
                 this.runImmutableHooks("onResponseError", err, this.api);
-                throw err;
+                if (!params?.suppress)
+                    throw err;
+                return err;
             }
             this.runImmutableHooks("onResponse", 
             // TODO: fix type error
@@ -396,8 +398,47 @@ let Bot = (() => {
                 return handler(context);
             });
         }
+        chosenInlineResult(trigger, handler) {
+            return this.on("chosen_inline_result", (context, next) => {
+                if ((typeof trigger === "string" && context.query === trigger) ||
+                    // @ts-expect-error
+                    (typeof trigger === "function" && trigger(context)) ||
+                    (trigger instanceof RegExp &&
+                        context.query &&
+                        trigger.test(context.query))) {
+                    //@ts-expect-error
+                    context.args =
+                        trigger instanceof RegExp ? context.query?.match(trigger) : null;
+                    // TODO: remove
+                    //@ts-expect-error
+                    return handler(context);
+                }
+                return next();
+            });
+        }
+        inlineQuery(trigger, handler, options = {}) {
+            // @ts-expect-error fix later...
+            if (options.onResult)
+                this.chosenInlineResult(trigger, options.onResult);
+            return this.on("inline_query", (context, next) => {
+                if ((typeof trigger === "string" && context.query === trigger) ||
+                    // @ts-expect-error
+                    (typeof trigger === "function" && trigger(context)) ||
+                    (trigger instanceof RegExp &&
+                        context.query &&
+                        trigger.test(context.query))) {
+                    //@ts-expect-error
+                    context.args =
+                        trigger instanceof RegExp ? context.query?.match(trigger) : null;
+                    // TODO: remove
+                    //@ts-expect-error
+                    return handler(context);
+                }
+                return next();
+            });
+        }
         hears(trigger, handler) {
-            return this.on(["message", "business_message"], (context, next) => {
+            return this.on("message", (context, next) => {
                 if ((typeof trigger === "string" && context.text === trigger) ||
                     // @ts-expect-error
                     (typeof trigger === "function" && trigger(context)) ||

package/dist/errors.d.ts

@@ -1,9 +1,10 @@
-import type { APIMethodParams, APIMethods, TelegramAPIResponseError, TelegramResponseParameters } from "@gramio/types";
+import type { APIMethods, TelegramAPIResponseError, TelegramResponseParameters } from "@gramio/types";
+import type { MaybeSuppressedParams } from "./types";
 export declare const ErrorKind: unique symbol;
 export declare class TelegramError<T extends keyof APIMethods> extends Error {
     method: T;
-    params: APIMethodParams<T>;
+    params: MaybeSuppressedParams<T>;
     code: number;
     payload?: TelegramResponseParameters;
-    constructor(error: TelegramAPIResponseError, method: T, params: APIMethodParams<T>);
+    constructor(error: TelegramAPIResponseError, method: T, params: MaybeSuppressedParams<T>);
 }

package/dist/plugin.d.ts

@@ -1,4 +1,4 @@
-import type { BotLike, Context, ContextType, MaybeArray, UpdateName } from "@gramio/contexts";
+import type { Context, ContextType, MaybeArray, UpdateName } from "@gramio/contexts";
 import type { APIMethods } from "@gramio/types";
 import type { DeriveDefinitions, ErrorDefinitions, Hooks } from "./types";
 import type { Bot } from "./bot";
@@ -37,10 +37,10 @@ export declare class Plugin<Errors extends ErrorDefinitions = {}, Derives extend
         new (...args: any): any;
         prototype: Error;
     }>(kind: Name, error: NewError): Plugin<Errors & { [name in Name]: InstanceType<NewError>; }, Derives>;
-    derive<Handler extends Hooks.Derive<Context<BotLike>>>(handler: Handler): Plugin<Errors, Derives & {
+    derive<Handler extends Hooks.Derive<Context<Bot>>>(handler: Handler): Plugin<Errors, Derives & {
         global: Awaited<ReturnType<Handler>>;
     }>;
-    derive<Update extends UpdateName, Handler extends Hooks.Derive<ContextType<BotLike, Update>>>(updateName: MaybeArray<Update>, handler: Handler): Plugin<Errors, Derives & {
+    derive<Update extends UpdateName, Handler extends Hooks.Derive<ContextType<Bot, Update>>>(updateName: MaybeArray<Update>, handler: Handler): Plugin<Errors, Derives & {
         [K in Update]: Awaited<ReturnType<Handler>>;
     }>;
     preRequest<Methods extends keyof APIMethods, Handler extends Hooks.PreRequest<Methods>>(methods: MaybeArray<Methods>, handler: Handler): this;

package/dist/types.d.ts

@@ -1,6 +1,7 @@
-import type { BotLike, Context, UpdateName } from "@gramio/contexts";
+import type { Context, UpdateName } from "@gramio/contexts";
 import type { APIMethodParams, APIMethodReturn, APIMethods, TelegramUser } from "@gramio/types";
 import type { NextMiddleware } from "middleware-io";
+import type { Bot } from "./bot";
 import type { TelegramError } from "./errors";
 export interface BotOptions {
     token?: string;
@@ -9,7 +10,7 @@ export interface BotOptions {
     };
 }
 export type Handler<T> = (context: T, next: NextMiddleware) => unknown;
-interface ErrorHandlerParams<Ctx extends Context<BotLike>, Kind extends string, Err> {
+interface ErrorHandlerParams<Ctx extends Context<Bot>, Kind extends string, Err> {
     context: Ctx;
     kind: Kind;
     error: Err;
@@ -20,9 +21,37 @@ type AnyTelegramError<Methods extends keyof APIMethods = keyof APIMethods> = {
 type AnyTelegramMethod<Methods extends keyof APIMethods> = {
     [APIMethod in Methods]: {
         method: APIMethod;
-        params: APIMethodParams<APIMethod>;
+        params: MaybeSuppressedParams<APIMethod>;
     };
 }[Methods];
+export interface Suppress<IsSuppressed extends boolean | undefined = undefined> {
+    /**
+     * Pass `true` if you want to suppress throwing errors of this method.
+     *
+     * **But this does not undo getting into the `onResponseError` hook**.
+     *
+     * @example
+     * ```ts
+     * const response = await bot.api.sendMessage({
+     * 		suppress: true,
+     * 		chat_id: "@not_found",
+     * 		text: "Suppressed method"
+     * });
+     *
+     * if(response instanceof TelegramError) console.error("sendMessage returns an error...")
+     * else console.log("Message has been sent successfully");
+     * ```
+     *
+     * */
+    suppress?: IsSuppressed;
+}
+export type MaybeSuppressedParams<Method extends keyof APIMethods, IsSuppressed extends boolean | undefined = undefined> = APIMethodParams<Method> & Suppress<IsSuppressed>;
+export type SuppressedAPIMethodParams<Method extends keyof APIMethods> = undefined extends APIMethodParams<Method> ? Suppress<true> : MaybeSuppressedParams<Method, true>;
+type MaybeSuppressedReturn<Method extends keyof APIMethods, IsSuppressed extends boolean | undefined = undefined> = true extends IsSuppressed ? TelegramError<Method> | APIMethodReturn<Method> : APIMethodReturn<Method>;
+export type SuppressedAPIMethodReturn<Method extends keyof APIMethods> = MaybeSuppressedReturn<Method, true>;
+export type SuppressedAPIMethods<Methods extends keyof APIMethods = keyof APIMethods> = {
+    [APIMethod in Methods]: APIMethodParams<APIMethod> extends undefined ? <IsSuppressed extends boolean | undefined = undefined>(params?: Suppress<IsSuppressed>) => Promise<MaybeSuppressedReturn<APIMethod, IsSuppressed>> : undefined extends APIMethodParams<APIMethod> ? <IsSuppressed extends boolean | undefined = undefined>(params?: MaybeSuppressedParams<APIMethod, IsSuppressed>) => Promise<MaybeSuppressedReturn<APIMethod, IsSuppressed>> : <IsSuppressed extends boolean | undefined = undefined>(params: MaybeSuppressedParams<APIMethod, IsSuppressed>) => Promise<MaybeSuppressedReturn<APIMethod, IsSuppressed>>;
+};
 type AnyTelegramMethodWithReturn<Methods extends keyof APIMethods> = {
     [APIMethod in Methods]: {
         method: APIMethod;
@@ -35,10 +64,10 @@ export declare namespace Hooks {
     type Derive<Ctx> = (context: Ctx) => MaybePromise<Record<string, unknown>>;
     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> | {
+    type OnErrorContext<Ctx extends Context<Bot>, T extends ErrorDefinitions> = ErrorHandlerParams<Ctx, "TELEGRAM", AnyTelegramError> | ErrorHandlerParams<Ctx, "UNKNOWN", Error> | {
         [K in keyof T]: ErrorHandlerParams<Ctx, K & string, T[K & string]>;
     }[keyof T];
-    type OnError<T extends ErrorDefinitions, Ctx extends Context<BotLike> = Context<BotLike>> = (options: OnErrorContext<Ctx, T>) => unknown;
+    type OnError<T extends ErrorDefinitions, Ctx extends Context<any> = Context<Bot>> = (options: OnErrorContext<Ctx, T>) => unknown;
     type OnStart = (context: {
         plugins: string[];
         info: TelegramUser;
@@ -48,7 +77,7 @@ 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 OnResponseError<Methods extends keyof APIMethods = keyof APIMethods> = (context: AnyTelegramError<Methods>, api: Bot["api"]) => unknown;
     type OnResponse<Methods extends keyof APIMethods = keyof APIMethods> = (context: AnyTelegramMethodWithReturn<Methods>) => unknown;
     interface Store<T extends ErrorDefinitions> {
         preRequest: PreRequest[];

package/dist/updates.js

@@ -33,24 +33,31 @@ class Updates {
         const UpdateContext = contexts_1.contextsMappings[updateType];
         if (!UpdateContext)
             throw new Error(updateType);
+        const updatePayload = data[updateType];
+        if (!updatePayload)
+            throw new Error("");
         try {
             let context = new UpdateContext({
                 bot: this.bot,
                 update: data,
-                payload: data[updateType],
+                // @ts-expect-error
+                payload: updatePayload,
                 type: updateType,
                 updateId: data.update_id,
             });
             if ("isEvent" in context && context.isEvent() && context.eventType) {
-                // @ts-expect-error contextsMappings is any
+                const payload = data.message ??
+                    data.edited_message ??
+                    data.channel_post ??
+                    data.edited_channel_post ??
+                    data.business_message;
+                if (!payload)
+                    throw new Error("Unsupported event??");
                 context = new contexts_1.contextsMappings[context.eventType]({
                     bot: this.bot,
                     update: data,
-                    payload: data.message ??
-                        data.edited_message ??
-                        data.channel_post ??
-                        data.edited_channel_post ??
-                        data.business_message,
+                    payload,
+                    // @ts-expect-error
                     type: context.eventType,
                     updateId: data.update_id,
                 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gramio",
-  "version": "0.0.26",
+  "version": "0.0.27",
   "description": "Powerful Telegram Bot API framework",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -25,15 +25,15 @@
   "license": "ISC",
   "devDependencies": {
     "@biomejs/biome": "1.6.4",
-    "@types/node": "^20.12.4",
-    "typescript": "^5.4.3"
+    "@types/node": "^20.12.5",
+    "typescript": "^5.4.4"
   },
   "dependencies": {
     "@gramio/callback-data": "^0.0.2",
-    "@gramio/contexts": "^0.0.8",
+    "@gramio/contexts": "^0.0.9",
     "@gramio/files": "^0.0.4",
     "@gramio/format": "^0.0.8",
-    "@gramio/keyboards": "^0.2.3",
+    "@gramio/keyboards": "^0.3.0",
     "@gramio/types": "^7.2.1",
     "inspectable": "^3.0.0",
     "middleware-io": "^2.8.1",