gramio 0.0.8 → 0.0.10

package/README.md

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

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,11 @@
-import type { ApiMethods } from "@gramio/types";
+import type { APIMethods } from "@gramio/types";
 import "reflect-metadata";
 import { BotOptions } from "./types";
 import { Updates } from "./updates";
 export declare class Bot {
     readonly options: BotOptions;
-    readonly api: ApiMethods;
+    readonly api: APIMethods;
     updates: Updates;
-    private _callApi;
     constructor(token: string, options?: Omit<BotOptions, "token">);
+    private _callApi;
 }

package/dist/bot.js

@@ -13,7 +13,7 @@ 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 TelegramError_1 = require("./TelegramError");
 const updates_1 = require("./updates");
 let Bot = class Bot {
     options = {};
@@ -21,6 +21,9 @@ let Bot = class Bot {
         get: (_target, method) => (args) => this._callApi(method, args),
     });
     updates = new updates_1.Updates(this);
+    constructor(token, options) {
+        this.options = { ...options, token };
+    }
     async _callApi(method, params = {}) {
         const url = `https://api.telegram.org/bot${this.options.token}/${method}`;
         const reqOptions = {
@@ -46,12 +49,9 @@ 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 TelegramError_1.TelegramError(data, method, params);
         return data.result;
     }
-    constructor(token, options) {
-        this.options = { ...options, token };
-    }
 };
 exports.Bot = Bot;
 exports.Bot = Bot = __decorate([

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export * from "./bot";
-export * from "./apiErrors";
+export * from "./TelegramError";
 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("./TelegramError"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("@gramio/contexts"), exports);
 __exportStar(require("@gramio/files"), exports);

package/dist/types.d.ts

@@ -1,7 +1,18 @@
-import { contextsMappings } from "@gramio/contexts";
+import { Context } from "@gramio/contexts";
+import { APIMethods } from "@gramio/types";
 import { NextMiddleware } from "middleware-io";
+import { TelegramError } from "./TelegramError";
 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 extends Error> {
+    context: Context;
+    kind: Kind;
+    error: Err;
+}
+type AnyTelegramError = {
+    [APIMethod in keyof APIMethods]: TelegramError<APIMethod>;
+}[keyof APIMethods];
+export type ErrorHandler = (options: ErrorHandlerParams<"TELEGRAM", AnyTelegramError> | ErrorHandlerParams<"UNKNOWN", Error>) => unknown;
+export {};

package/dist/updates.d.ts

@@ -1,17 +1,19 @@
-import { Context, contextsMappings } from "@gramio/contexts";
+import { Context, UpdateName, contextsMappings } from "@gramio/contexts";
 import type { TelegramUpdate } from "@gramio/types";
 import type { Bot } from "./bot";
-import { THandler, UpdateNames } from "./types";
+import { ErrorHandler, Handler } from "./types";
 export declare class Updates {
     private readonly bot;
     private isStarted;
     private offset;
     private composer;
+    private errorHandler;
     constructor(bot: Bot);
-    on<T extends UpdateNames>(updateName: T, handler: THandler<InstanceType<(typeof contextsMappings)[T]>>): this;
-    use(handler: THandler<Context>): this;
+    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<null>;
+    startPolling(): Promise<void>;
     startFetchLoop(): Promise<void>;
     stopPolling(): void;
+    onError(handler: ErrorHandler): void;
 }

package/dist/updates.js

@@ -3,46 +3,73 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Updates = void 0;
 const contexts_1 = require("@gramio/contexts");
 const middleware_io_1 = require("middleware-io");
+const _TelegramError_1 = require("#TelegramError");
 class Updates {
     bot;
     isStarted = false;
     offset = 0;
     composer = middleware_io_1.Composer.builder();
+    errorHandler;
     constructor(bot) {
         this.bot = bot;
     }
     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((ctx, error) => {
+            if (error instanceof _TelegramError_1.TelegramError)
+                return this.errorHandler?.({
+                    context: ctx,
+                    kind: "TELEGRAM",
+                    error: error,
+                });
+            this.errorHandler?.({
+                context: ctx,
+                kind: "UNKNOWN",
+                error: error,
+            });
+        })
+            .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({
+                //@ts-expect-error
                 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]({
+                    //@ts-expect-error
+                    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);
@@ -56,7 +83,7 @@ class Updates {
             throw new Error("[UPDATES] Polling already started!");
         this.isStarted = true;
         this.startFetchLoop();
-        return null;
+        return;
     }
     async startFetchLoop() {
         while (this.isStarted) {
@@ -72,5 +99,8 @@ class Updates {
     stopPolling() {
         this.isStarted = false;
     }
+    onError(handler) {
+        this.errorHandler = handler;
+    }
 }
 exports.Updates = Updates;

package/package.json

@@ -1,26 +1,27 @@
 {
     "name": "gramio",
-    "version": "0.0.8",
+    "version": "0.0.10",
     "description": "WIP",
     "main": "./dist/index.js",
     "types": "./dist/index.d.ts",
     "scripts": {
+        "type": "tsc --noEmit",
         "lint": "bun check ./src",
-        "lint:fix": "bun lint --apply"
+        "lint:fix": "bun lint --apply",
+        "prepublishOnly": "tsc"
     },
     "author": "kravets",
     "license": "ISC",
     "devDependencies": {
         "@biomejs/biome": "1.5.3",
-        "@gramio/types": "^7.0.17",
-        "@types/node": "^20.11.17"
+        "@gramio/types": "^7.1.1",
+        "@types/node": "^20.11.19"
     },
     "dependencies": {
-        "@gramio/contexts": "^0.0.1",
+        "@gramio/contexts": "^0.0.2",
         "@gramio/files": "^0.0.3",
         "@gramio/format": "^0.0.7",
         "@gramio/keyboards": "^0.1.6",
-        "common-tags": "^1.8.2",
         "form-data-encoder": "^4.0.2",
         "inspectable": "^2.1.0",
         "middleware-io": "^2.8.1",

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);
-}