gramio 0.0.16 → 0.0.17

package/dist/bot.d.ts

@@ -1,12 +1,14 @@
 import { Context, ContextType, MaybeArray, UpdateName } from "@gramio/contexts";
-import type { APIMethods } from "@gramio/types";
+import type { APIMethodParams, APIMethods, TelegramUser } from "@gramio/types";
 import "reflect-metadata";
 import { Plugin } from "./plugin";
 import { BotOptions, DeriveDefinitions, ErrorDefinitions, Handler, Hooks } from "./types";
 import { Updates } from "./updates";
 export declare class Bot<Errors extends ErrorDefinitions = {}, Derives extends DeriveDefinitions = DeriveDefinitions> {
     readonly options: BotOptions;
+    info: TelegramUser | undefined;
     readonly api: APIMethods;
+    private dependencies;
     private errorsDefinitions;
     private errorHandler;
     updates: Updates;
@@ -66,7 +68,13 @@ export declare class Bot<Errors extends ErrorDefinitions = {}, Derives extends D
     derive<Update extends UpdateName, Handler extends Hooks.Derive<ContextType<typeof this, Update>>>(updateName: MaybeArray<Update>, handler: Handler): Bot<Errors, Derives & {
         [K in Update]: Awaited<ReturnType<Handler>>;
     }>;
+    onStart(handler: Hooks.OnStart): 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>(plugin: NewPlugin): Bot<Errors & NewPlugin["Errors"], Derives & NewPlugin["Derives"]>;
+    start({ webhook, dropPendingUpdates, allowedUpdates, }?: {
+        webhook?: Omit<APIMethodParams<"setWebhook">, "drop_pending_updates" | "allowed_updates">;
+        dropPendingUpdates?: boolean;
+        allowedUpdates?: NonNullable<APIMethodParams<"getUpdates">>["allowed_updates"];
+    }): Promise<TelegramUser>;
 }

package/dist/bot.js

@@ -17,9 +17,11 @@ const errors_1 = require("./errors");
 const updates_1 = require("./updates");
 let Bot = class Bot {
     options = {};
+    info;
     api = new Proxy({}, {
         get: (_target, method) => (args) => this._callApi(method, args),
     });
+    dependencies = [];
     errorsDefinitions = {
         TELEGRAM: errors_1.TelegramError,
     };
@@ -45,6 +47,7 @@ let Bot = class Bot {
             },
         ],
         onError: [],
+        onStart: [],
     };
     constructor(token, options) {
         this.options = { ...options, token };
@@ -58,6 +61,8 @@ let Bot = class Bot {
     }
     async runImmutableHooks(type, context) {
         for await (const hook of this.hooks[type]) {
+            //TODO: solve that later
+            //@ts-expect-error
             await hook(context);
         }
     }
@@ -162,6 +167,10 @@ let Bot = class Bot {
             });
         return this;
     }
+    onStart(handler) {
+        this.hooks.onStart.push(handler);
+        return this;
+    }
     on(updateName, handler) {
         this.updates.on(updateName, handler);
         return this;
@@ -171,6 +180,10 @@ let Bot = class Bot {
         return this;
     }
     extend(plugin) {
+        if (plugin.dependencies.some((dep) => !this.dependencies.includes(dep)))
+            throw new Error(`The «${plugin.name}» plugin needs dependencies registered before: ${plugin.dependencies
+                .filter((dep) => !this.dependencies.includes(dep))
+                .join(", ")}`);
         for (const [key, value] of Object.entries(plugin.errorsDefinitions)) {
             if (this.errorsDefinitions[key])
                 this.errorsDefinitions[key] = value;
@@ -182,8 +195,40 @@ let Bot = class Bot {
             else
                 this.derive(updateName, derive);
         }
+        this.dependencies.push(plugin.name);
         return this;
     }
+    async start({ webhook, dropPendingUpdates, allowedUpdates, } = {}) {
+        //TODO: maybe it useless??
+        this.info = await this.api.getMe();
+        if (!webhook) {
+            await this.api.deleteWebhook({
+                drop_pending_updates: dropPendingUpdates,
+            });
+            await this.updates.startPolling({
+                allowed_updates: allowedUpdates,
+            });
+            this.runImmutableHooks("onStart", {
+                plugins: this.dependencies,
+                info: this.info,
+                updatesFrom: "long-polling",
+            });
+            return this.info;
+        }
+        if (this.updates.isStarted)
+            this.updates.stopPolling();
+        await this.api.setWebhook({
+            ...webhook,
+            drop_pending_updates: dropPendingUpdates,
+            allowed_updates: allowedUpdates,
+        });
+        this.runImmutableHooks("onStart", {
+            plugins: this.dependencies,
+            info: this.info,
+            updatesFrom: "long-polling",
+        });
+        return this.info;
+    }
 };
 exports.Bot = Bot;
 exports.Bot = Bot = __decorate([

package/dist/index.d.ts

@@ -2,6 +2,7 @@ export * from "./bot";
 export * from "./errors";
 export * from "./types";
 export * from "./plugin";
+export * from "./webhook";
 export * from "@gramio/contexts";
 export * from "@gramio/files";
 export * from "@gramio/keyboards";

package/dist/index.js

@@ -18,6 +18,7 @@ __exportStar(require("./bot"), exports);
 __exportStar(require("./errors"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("./plugin"), exports);
+__exportStar(require("./webhook"), exports);
 __exportStar(require("@gramio/contexts"), exports);
 __exportStar(require("@gramio/files"), exports);
 __exportStar(require("@gramio/keyboards"), exports);

package/dist/plugin.d.ts

@@ -9,7 +9,10 @@ export declare class Plugin<Errors extends ErrorDefinitions = {}, Derives extend
         new (...args: any): any;
         prototype: Error;
     }>;
-    constructor(name: string);
+    dependencies: string[];
+    constructor(name: string, { dependencies }?: {
+        dependencies?: string[];
+    });
     /**
      * Register custom class-error in plugin
      **/

package/dist/plugin.js

@@ -9,8 +9,11 @@ class Plugin {
     derives = [];
     name;
     errorsDefinitions = {};
-    constructor(name) {
+    dependencies = [];
+    constructor(name, { dependencies } = {}) {
         this.name = name;
+        if (dependencies)
+            this.dependencies = dependencies;
     }
     /**
      * Register custom class-error in plugin

package/dist/types.d.ts

@@ -1,5 +1,5 @@
 import { BotLike, Context, UpdateName } from "@gramio/contexts";
-import { APIMethodParams, APIMethods } from "@gramio/types";
+import { APIMethodParams, APIMethods, TelegramUser } from "@gramio/types";
 import { NextMiddleware } from "middleware-io";
 import { TelegramError } from "./errors";
 export interface BotOptions {
@@ -29,9 +29,15 @@ export declare namespace Hooks {
         [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 OnStart = (context: {
+        plugins: string[];
+        info: TelegramUser;
+        updatesFrom: "webhook" | "long-polling";
+    }) => unknown;
     interface Store<T extends ErrorDefinitions> {
         preRequest: PreRequest[];
         onError: OnError<T>[];
+        onStart: OnStart[];
     }
 }
 export type ErrorDefinitions = Record<string, Error>;

package/dist/updates.d.ts

@@ -1,11 +1,11 @@
 import { Context, MaybeArray, UpdateName } from "@gramio/contexts";
-import type { TelegramUpdate } from "@gramio/types";
+import type { APIMethodParams, TelegramUpdate } from "@gramio/types";
 import { CaughtMiddlewareHandler } from "middleware-io";
 import type { Bot } from "./bot";
 import { Handler } from "./types";
 export declare class Updates {
     private readonly bot;
-    private isStarted;
+    isStarted: boolean;
     private offset;
     private composer;
     private onError;
@@ -13,7 +13,8 @@ export declare class Updates {
     on<T extends UpdateName>(updateName: MaybeArray<T>, handler: Handler<any>): this;
     use(handler: Handler<any>): this;
     handleUpdate(data: TelegramUpdate): Promise<void>;
-    startPolling(): Promise<void>;
-    startFetchLoop(): Promise<void>;
+    /**@deprecated use bot.start instead */
+    startPolling(params?: APIMethodParams<"getUpdates">): Promise<void>;
+    startFetchLoop(params?: APIMethodParams<"getUpdates">): Promise<void>;
     stopPolling(): void;
 }

package/dist/updates.js

@@ -63,17 +63,19 @@ class Updates {
             throw new Error(`[UPDATES] Update type ${updateType} not supported.`);
         }
     }
-    async startPolling() {
+    /**@deprecated use bot.start instead */
+    async startPolling(params = {}) {
         if (this.isStarted)
             throw new Error("[UPDATES] Polling already started!");
         this.isStarted = true;
-        this.startFetchLoop();
+        this.startFetchLoop(params);
         return;
     }
-    async startFetchLoop() {
+    async startFetchLoop(params = {}) {
         while (this.isStarted) {
             const updates = await this.bot.api.getUpdates({
                 offset: this.offset,
+                ...params,
             });
             for await (const update of updates) {
                 //TODO: update errors

package/dist/webhook/adapters.d.ts

@@ -0,0 +1,16 @@
+import { TelegramUpdate } from "@gramio/types";
+export interface FrameworkHandler {
+    update: TelegramUpdate;
+    header?: string;
+}
+export type FrameworkAdapter = (...args: any[]) => FrameworkHandler;
+export declare const frameworks: {
+    elysia: ({ body, headers }: any) => {
+        update: any;
+        header: any;
+    };
+    fastify: (request: any) => {
+        update: any;
+        header: any;
+    };
+};

package/dist/webhook/adapters.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.frameworks = void 0;
+const SECRET_TOKEN_HEADER = "X-Telegram-Bot-Api-Secret-Token";
+exports.frameworks = {
+    elysia: ({ body, headers }) => ({
+        update: body,
+        header: headers[SECRET_TOKEN_HEADER],
+    }),
+    fastify: (request) => ({
+        update: request.body,
+        header: request.headers[SECRET_TOKEN_HEADER],
+    }),
+};

package/dist/webhook/index.d.ts

@@ -0,0 +1,3 @@
+import { Bot } from "../bot";
+import { frameworks } from "./adapters";
+export declare function webhookHandler(bot: Bot, framework: keyof typeof frameworks): (...args: any[]) => Promise<void>;

package/dist/webhook/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webhookHandler = void 0;
+const adapters_1 = require("./adapters");
+function webhookHandler(bot, framework) {
+    const frameworkAdapter = adapters_1.frameworks[framework];
+    return async (...args) => {
+        const { update } = frameworkAdapter(...args);
+        await bot.updates.handleUpdate(update);
+    };
+}
+exports.webhookHandler = webhookHandler;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "gramio",
-    "version": "0.0.16",
+    "version": "0.0.17",
     "description": "Powerful Telegram Bot API framework",
     "main": "./dist/index.js",
     "types": "./dist/index.d.ts",
@@ -25,7 +25,7 @@
     "license": "ISC",
     "devDependencies": {
         "@biomejs/biome": "1.5.3",
-        "@gramio/types": "^7.1.3",
+        "@gramio/types": "^7.1.4",
         "@types/node": "^20.11.20",
         "typescript": "^5.3.3"
     },