gramio 0.0.9 → 0.0.11

package/dist/TelegramError.d.ts

@@ -0,0 +1,8 @@
+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/{apiErrors.js → TelegramError.js}

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

package/dist/bot.d.ts

@@ -1,11 +1,60 @@
-import type { ApiMethods } from "@gramio/types";
+import type { APIMethods } from "@gramio/types";
 import "reflect-metadata";
-import { BotOptions } from "./types";
+import { BotOptions, ErrorDefinitions, Hooks } from "./types";
 import { Updates } from "./updates";
-export declare class Bot {
+export declare class Bot<Errors extends ErrorDefinitions = {}> {
     readonly options: BotOptions;
-    readonly api: ApiMethods;
+    readonly api: APIMethods;
+    private errorsDefinitions;
+    private errorHandler;
     updates: Updates;
-    private _callApi;
+    private hooks;
     constructor(token: string, options?: Omit<BotOptions, "token">);
+    private runHooks;
+    private runImmutableHooks;
+    private _callApi;
+    /**
+     * Register custom class-error for type-safe catch in `onError` hook
+     *
+     * @example
+     * ```ts
+     * export class NoRights extends Error {
+     *     needRole: "admin" | "moderator";
+     *
+     *     constructor(role: "admin" | "moderator") {
+     *         super();
+     *         this.needRole = role;
+     *     }
+     * }
+     *
+     * const bot = new Bot(process.env.TOKEN!)
+     *     .error("NO_RIGHTS", NoRights)
+     *     .onError(({ context, kind, error }) => {
+     *         if (context.is("message") && kind === "NO_RIGHTS")
+     *             return context.send(
+     *                 format`You don't have enough rights! You need to have an «${bold(
+     *                     error.needRole
+     *                 )}» role.`
+     *             );
+     *     });
+     *
+     * bot.updates.on("message", (context) => {
+     *     if (context.text === "bun") throw new NoRights("admin");
+     * });
+     * ```
+     */
+    error<Name extends string, NewError extends {
+        new (...args: any): any;
+        prototype: Error;
+    }>(kind: Name, error: NewError): Bot<Errors & { [name in Name]: InstanceType<NewError>; }>;
+    /**
+     * Set error handler.
+     * @example
+     * ```ts
+     * bot.updates.onError(({ context, kind, error }) => {
+     * 	if(context.is("message")) return context.send(`${kind}: ${error.message}`);
+     * })
+     * ```
+     */
+    onError(handler: Hooks.OnError<Errors>): this;
 }

package/dist/bot.js

@@ -13,24 +13,68 @@ const form_data_encoder_1 = require("form-data-encoder");
 const inspectable_1 = require("inspectable");
 require("reflect-metadata");
 const undici_1 = require("undici");
-const apiErrors_1 = require("./apiErrors");
+const errors_1 = require("./errors");
 const updates_1 = require("./updates");
 let Bot = class Bot {
     options = {};
     api = new Proxy({}, {
         get: (_target, method) => (args) => this._callApi(method, args),
     });
-    updates = new updates_1.Updates(this);
+    errorsDefinitions = {
+        TELEGRAM: errors_1.TelegramError,
+    };
+    errorHandler(context, error) {
+        return this.runImmutableHooks("onError", {
+            context,
+            //@ts-expect-error ErrorKind exists if user register error-class with .error("kind", SomeError);
+            kind: error.constructor[errors_1.ErrorKind] ?? "UNKNOWN",
+            error: error,
+        });
+    }
+    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];
+                if (formattable)
+                    ctx.params = formattable(ctx.params);
+                return ctx;
+            },
+        ],
+        onError: [],
+    };
+    constructor(token, options) {
+        this.options = { ...options, token };
+    }
+    async runHooks(type, context) {
+        let data = context;
+        for await (const hook of this.hooks[type]) {
+            data = await hook(data);
+        }
+        return data;
+    }
+    async runImmutableHooks(type, context) {
+        for await (const hook of this.hooks[type]) {
+            await hook(context);
+        }
+    }
     async _callApi(method, params = {}) {
         const url = `https://api.telegram.org/bot${this.options.token}/${method}`;
         const reqOptions = {
             method: "POST",
             duplex: "half",
         };
-        const formattable = format_1.FormattableMap[method];
-        // biome-ignore lint/style/noParameterAssign: mutate formattable
-        if (formattable && params)
-            params = formattable(params);
+        const context = await this.runHooks("preRequest", 
+        // TODO: fix type error
+        // @ts-expect-error
+        {
+            method,
+            params,
+        });
+        // biome-ignore lint/style/noParameterAssign: mutate params
+        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);
@@ -46,11 +90,57 @@ let Bot = class Bot {
         const response = await (0, undici_1.fetch)(url, reqOptions);
         const data = (await response.json());
         if (!data.ok)
-            throw new apiErrors_1.APIError({ method, params }, data);
+            throw new errors_1.TelegramError(data, method, params);
         return data.result;
     }
-    constructor(token, options) {
-        this.options = { ...options, token };
+    /**
+     * Register custom class-error for type-safe catch in `onError` hook
+     *
+     * @example
+     * ```ts
+     * export class NoRights extends Error {
+     *     needRole: "admin" | "moderator";
+     *
+     *     constructor(role: "admin" | "moderator") {
+     *         super();
+     *         this.needRole = role;
+     *     }
+     * }
+     *
+     * const bot = new Bot(process.env.TOKEN!)
+     *     .error("NO_RIGHTS", NoRights)
+     *     .onError(({ context, kind, error }) => {
+     *         if (context.is("message") && kind === "NO_RIGHTS")
+     *             return context.send(
+     *                 format`You don't have enough rights! You need to have an «${bold(
+     *                     error.needRole
+     *                 )}» role.`
+     *             );
+     *     });
+     *
+     * bot.updates.on("message", (context) => {
+     *     if (context.text === "bun") throw new NoRights("admin");
+     * });
+     * ```
+     */
+    error(kind, error) {
+        //@ts-expect-error Set ErrorKind
+        error[errors_1.ErrorKind] = kind;
+        this.errorsDefinitions[kind] = error;
+        return this;
+    }
+    /**
+     * Set error handler.
+     * @example
+     * ```ts
+     * bot.updates.onError(({ context, kind, error }) => {
+     * 	if(context.is("message")) return context.send(`${kind}: ${error.message}`);
+     * })
+     * ```
+     */
+    onError(handler) {
+        this.hooks.onError.push(handler);
+        return this;
     }
 };
 exports.Bot = Bot;
@@ -58,4 +148,5 @@ exports.Bot = Bot = __decorate([
     (0, inspectable_1.Inspectable)({
         serialize: () => ({}),
     })
+    // biome-ignore lint/complexity/noBannedTypes: <explanation>
 ], Bot);

package/dist/errors.d.ts

@@ -0,0 +1,9 @@
+import { APIMethodParams, APIMethods, TelegramAPIResponseError, TelegramResponseParameters } from "@gramio/types";
+export declare const ErrorKind: unique symbol;
+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/errors.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TelegramError = exports.ErrorKind = void 0;
+exports.ErrorKind = Symbol("ErrorKind");
+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;
+//@ts-expect-error
+TelegramError.constructor[exports.ErrorKind] = "TELEGRAM";

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export * from "./bot";
-export * from "./apiErrors";
+export * from "./errors";
 export * from "./types";
 export * from "@gramio/contexts";
 export * from "@gramio/files";

package/dist/index.js

@@ -15,7 +15,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./bot"), exports);
-__exportStar(require("./apiErrors"), exports);
+__exportStar(require("./errors"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("@gramio/contexts"), exports);
 __exportStar(require("@gramio/files"), exports);

package/dist/types.d.ts

@@ -1,7 +1,39 @@
-import { contextsMappings } from "@gramio/contexts";
+import { Context } from "@gramio/contexts";
+import { APIMethodParams, APIMethods } from "@gramio/types";
 import { NextMiddleware } from "middleware-io";
+import { TelegramError } from "./errors";
 export interface BotOptions {
     token?: string;
 }
-export type THandler<T> = (context: T, next: NextMiddleware) => unknown;
-export type UpdateNames = keyof typeof contextsMappings;
+export type Handler<T> = (context: T, next: NextMiddleware) => unknown;
+interface ErrorHandlerParams<Kind extends string, Err> {
+    context: Context;
+    kind: Kind;
+    error: Err;
+}
+type AnyTelegramError = {
+    [APIMethod in keyof APIMethods]: TelegramError<APIMethod>;
+}[keyof APIMethods];
+type AnyTelegramMethod = {
+    [APIMethod in keyof APIMethods]: {
+        method: APIMethod;
+        params: APIMethodParams<APIMethod>;
+    };
+}[keyof APIMethods];
+type MaybePromise<T> = T | Promise<T>;
+export declare namespace Hooks {
+    type PreRequestContext = AnyTelegramMethod;
+    type PreRequest = (ctx: PreRequestContext) => MaybePromise<PreRequestContext>;
+    type OnErrorContext<T extends ErrorDefinitions> = ErrorHandlerParams<"TELEGRAM", AnyTelegramError> | ErrorHandlerParams<"UNKNOWN", Error> | {
+        [K in keyof T]: ErrorHandlerParams<K & string, T[K & string]>;
+    }[keyof T];
+    type OnError<T extends ErrorDefinitions> = (options: OnErrorContext<T>) => unknown;
+    interface Store<T extends ErrorDefinitions> {
+        preRequest: PreRequest[];
+        onError: OnError<T>[];
+    }
+}
+export type ErrorDefinitions = Record<string, {
+    prototype: Error;
+}>;
+export {};

package/dist/updates.d.ts

@@ -1,15 +1,17 @@
-import { Context, contextsMappings } from "@gramio/contexts";
+import { Context, UpdateName, contextsMappings } from "@gramio/contexts";
 import type { TelegramUpdate } from "@gramio/types";
+import { CaughtMiddlewareHandler } from "middleware-io";
 import type { Bot } from "./bot";
-import { THandler, UpdateNames } from "./types";
+import { Handler } from "./types";
 export declare class Updates {
     private readonly bot;
     private isStarted;
     private offset;
     private composer;
-    constructor(bot: Bot);
-    on<T extends UpdateNames>(updateName: T, handler: THandler<InstanceType<(typeof contextsMappings)[T]>>): this;
-    use(handler: THandler<Context>): this;
+    private onError;
+    constructor(bot: Bot<any>, onError: CaughtMiddlewareHandler<Context>);
+    on<T extends UpdateName>(updateName: T, handler: Handler<InstanceType<(typeof contextsMappings)[T]>>): this;
+    use(handler: Handler<Context>): this;
     handleUpdate(data: TelegramUpdate): Promise<void>;
     startPolling(): Promise<void>;
     startFetchLoop(): Promise<void>;

package/dist/updates.js

@@ -4,45 +4,58 @@ exports.Updates = void 0;
 const contexts_1 = require("@gramio/contexts");
 const middleware_io_1 = require("middleware-io");
 class Updates {
+    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
     bot;
     isStarted = false;
     offset = 0;
     composer = middleware_io_1.Composer.builder();
-    constructor(bot) {
+    onError;
+    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+    constructor(bot, onError) {
         this.bot = bot;
+        this.onError = onError;
     }
     on(updateName, handler) {
-        return this.use((context, next) => {
+        return this.use(async (context, next) => {
             //TODO: fix typings
             if (context.is(updateName))
-                handler(context, next);
+                await handler(context, next);
             else
-                next();
+                await next();
         });
     }
     use(handler) {
-        this.composer.use(handler);
+        this.composer.caught(this.onError).use(handler);
         return this;
     }
     async handleUpdate(data) {
         const updateType = Object.keys(data).at(1);
         this.offset = data.update_id + 1;
+        const UpdateContext = contexts_1.contextsMappings[updateType];
+        if (!UpdateContext)
+            return;
         try {
-            const context = new contexts_1.contextsMappings[updateType]({
-                // @ts-expect-error
+            let context = new UpdateContext({
                 bot: this.bot,
                 update: data,
-                //TODO: fix
-                //@ts-ignore
+                //@ts-expect-error
                 payload: data[updateType],
                 type: updateType,
                 updateId: data.update_id,
-                // raw: {
-                // 	update: data,
-                // 	updateId: data.update_id,
-                // 	updateType,
-                // },
             });
+            if ("isEvent" in context && context.isEvent() && context.eventType) {
+                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,
+                    type: context.eventType,
+                    updateId: data.update_id,
+                });
+            }
             this.composer.compose()(
             //TODO: fix typings
             context, middleware_io_1.noopNext);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "gramio",
-    "version": "0.0.9",
+    "version": "0.0.11",
     "description": "WIP",
     "main": "./dist/index.js",
     "types": "./dist/index.d.ts",
@@ -14,7 +14,7 @@
     "license": "ISC",
     "devDependencies": {
         "@biomejs/biome": "1.5.3",
-        "@gramio/types": "^7.1.0",
+        "@gramio/types": "^7.1.1",
         "@types/node": "^20.11.19"
     },
     "dependencies": {

package/dist/apiErrors.d.ts

@@ -1,12 +0,0 @@
-import { TelegramAPIResponseError } from "@gramio/types";
-export interface APIErrorDetails {
-    method: string;
-    params: Record<string, any>;
-}
-export declare class APIError extends Error {
-    method: string;
-    params: Record<string, any>;
-    code: number;
-    payload?: TelegramAPIResponseError["parameters"];
-    constructor({ method, params }: APIErrorDetails, error: TelegramAPIResponseError);
-}