gramio 0.0.50 → 0.1.0

package/dist/types.d.ts

@@ -1,242 +0,0 @@
-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";
-import type { Plugin } from "./plugin";
-/** Bot options that you can provide to {@link Bot} constructor */
-export interface BotOptions {
-    /** Bot token */
-    token: string;
-    /** List of plugins enabled by default */
-    plugins?: {
-        /** Pass `false` to disable plugin. @default true */
-        format?: boolean;
-    };
-    /** Options to configure how to send requests to the Telegram Bot API */
-    api: {
-        /** Configure {@link fetch} parameters */
-        fetchOptions?: Parameters<typeof fetch>[1];
-        /** URL which will be used to send requests to. @default "https://api.telegram.org/bot" */
-        baseURL: string;
-        /**
-         * 	Should we send requests to `test` data center?
-         * 	The test environment is completely separate from the main environment, so you will need to create a new user account and a new bot with `@BotFather`.
-         *
-         * 	[Documentation](https://core.telegram.org/bots/webapps#using-bots-in-the-test-environment)
-         * 	@default false
-         * */
-        useTest?: boolean;
-        /**
-         * Time in milliseconds before calling {@link APIMethods.getUpdates | getUpdates} again
-         * @default 1000
-         */
-        retryGetUpdatesWait?: number;
-    };
-}
-/**
- * Handler is a function with context and next function arguments
- *
- * @example
- * ```ts
- * const handler: Handler<ContextType<Bot, "message">> = (context, _next) => context.send("HI!");
- *
- * bot.on("message", handler)
- * ```
- */
-export type Handler<T> = (context: T, next: NextMiddleware) => unknown;
-interface ErrorHandlerParams<Ctx extends Context<AnyBot>, Kind extends string, Err> {
-    context: Ctx;
-    kind: Kind;
-    error: Err;
-}
-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: MaybeSuppressedParams<APIMethod>;
-    };
-}[Methods];
-/**
- * Interface for add `suppress` param to params
- */
-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;
-}
-/** Type that assign API params with {@link Suppress} */
-export type MaybeSuppressedParams<Method extends keyof APIMethods, IsSuppressed extends boolean | undefined = undefined> = APIMethodParams<Method> & Suppress<IsSuppressed>;
-/** Return method params but with {@link Suppress} */
-export type SuppressedAPIMethodParams<Method extends keyof APIMethods> = undefined extends APIMethodParams<Method> ? Suppress<true> : MaybeSuppressedParams<Method, true>;
-/** Type that return MaybeSuppressed API method ReturnType */
-type MaybeSuppressedReturn<Method extends keyof APIMethods, IsSuppressed extends boolean | undefined = undefined> = true extends IsSuppressed ? TelegramError<Method> | APIMethodReturn<Method> : APIMethodReturn<Method>;
-/** Type that return {@link Suppress | Suppressed} API method ReturnType */
-export type SuppressedAPIMethodReturn<Method extends keyof APIMethods> = MaybeSuppressedReturn<Method, true>;
-/** Map of APIMethods but with {@link Suppress} */
-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;
-        params: APIMethodParams<APIMethod>;
-        response: APIMethodReturn<APIMethod>;
-    };
-}[Methods];
-/** Type for maybe {@link Promise} or may not */
-export type MaybePromise<T> = Promise<T> | T;
-/**
- * Namespace with GramIO hooks types
- *
- * [Documentation](https://gramio.dev/hooks/overview.html)
- * */
-export declare namespace Hooks {
-    /** Derive */
-    type Derive<Ctx> = (context: Ctx) => MaybePromise<Record<string, unknown>>;
-    /** Argument type for {@link PreRequest} */
-    type PreRequestContext<Methods extends keyof APIMethods> = AnyTelegramMethod<Methods>;
-    /**
-     * Type for `preRequest` hook
-     *
-     * @example
-     * ```typescript
-     * import { Bot } from "gramio";
-     *
-     * const bot = new Bot(process.env.TOKEN!).preRequest((context) => {
-     *     if (context.method === "sendMessage") {
-     *         context.params.text = "mutate params";
-     *     }
-     *
-     *     return context;
-     * });
-     *
-     * bot.start();
-     * ```
-     *
-     * [Documentation](https://gramio.dev/hooks/pre-request.html)
-     *  */
-    type PreRequest<Methods extends keyof APIMethods = keyof APIMethods> = (ctx: PreRequestContext<Methods>) => MaybePromise<PreRequestContext<Methods>>;
-    /** Argument type for {@link OnError} */
-    type OnErrorContext<Ctx extends Context<AnyBot>, 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 for `onError` hook
-     *
-     * @example
-     * ```typescript
-     * bot.on("message", () => {
-     *     bot.api.sendMessage({
-     *         chat_id: "@not_found",
-     *         text: "Chat not exists....",
-     *     });
-     * });
-     *
-     * bot.onError(({ context, kind, error }) => {
-     *     if (context.is("message")) return context.send(`${kind}: ${error.message}`);
-     * });
-     * ```
-     *
-     * [Documentation](https://gramio.dev/hooks/on-error.html)
-     *  */
-    type OnError<T extends ErrorDefinitions, Ctx extends Context<any> = Context<AnyBot>> = (options: OnErrorContext<Ctx, T>) => unknown;
-    /**
-     * Type for `onStart` hook
-     *
-     * @example
-     * ```typescript
-     * import { Bot } from "gramio";
-     *
-     * const bot = new Bot(process.env.TOKEN!).onStart(
-     *     ({ plugins, info, updatesFrom }) => {
-     *         console.log(`plugin list - ${plugins.join(", ")}`);
-     *         console.log(`bot username is @${info.username}`);
-     * 		   console.log(`updates from ${updatesFrom}`);
-     *     }
-     * );
-     *
-     * bot.start();
-     * ```
-     *
-     * [Documentation](https://gramio.dev/hooks/on-start.html)
-     *  */
-    type OnStart = (context: {
-        plugins: string[];
-        info: TelegramUser;
-        updatesFrom: "webhook" | "long-polling";
-    }) => unknown;
-    /**
-     * Type for `onStop` hook
-     *
-     * @example
-     * ```typescript
-     * import { Bot } from "gramio";
-     *
-     * const bot = new Bot(process.env.TOKEN!).onStop(
-     *     ({ plugins, info, updatesFrom }) => {
-     *         console.log(`plugin list - ${plugins.join(", ")}`);
-     *         console.log(`bot username is @${info.username}`);
-     *     }
-     * );
-     *
-     * bot.start();
-     * bot.stop();
-     * ```
-     *
-     * [Documentation](https://gramio.dev/hooks/on-stop.html)
-     *  */
-    type OnStop = (context: {
-        plugins: string[];
-        info: TelegramUser;
-    }) => unknown;
-    /**
-     * Type for `onResponseError` hook
-     *
-     * [Documentation](https://gramio.dev/hooks/on-response-error.html)
-     * */
-    type OnResponseError<Methods extends keyof APIMethods = keyof APIMethods> = (context: AnyTelegramError<Methods>, api: Bot["api"]) => unknown;
-    /**
-     * Type for `onResponse` hook
-     *
-     * [Documentation](https://gramio.dev/hooks/on-response.html)
-     *  */
-    type OnResponse<Methods extends keyof APIMethods = keyof APIMethods> = (context: AnyTelegramMethodWithReturn<Methods>) => unknown;
-    /** Store hooks */
-    interface Store<T extends ErrorDefinitions> {
-        preRequest: PreRequest[];
-        onResponse: OnResponse[];
-        onResponseError: OnResponseError[];
-        onError: OnError<T>[];
-        onStart: OnStart[];
-        onStop: OnStop[];
-    }
-}
-/** Error map should be map of string: error */
-export type ErrorDefinitions = Record<string, Error>;
-/** Map of derives */
-export type DeriveDefinitions = Record<UpdateName | "global", {}>;
-export type FilterDefinitions = Record<string, (...args: any[]) => (context: Context<Bot>) => boolean>;
-/** Type of Bot that accepts any generics */
-export type AnyBot = Bot<any, any>;
-/** Type of Bot that accepts any generics */
-export type AnyPlugin = Plugin<any, any>;
-export {};

package/dist/types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/updates.d.ts

@@ -1,17 +0,0 @@
-import { type Context } from "@gramio/contexts";
-import type { APIMethodParams, TelegramUpdate } from "@gramio/types";
-import type { CaughtMiddlewareHandler } from "middleware-io";
-import { Composer } from "./composer";
-import type { AnyBot } from "./types";
-export declare class Updates {
-    private readonly bot;
-    isStarted: boolean;
-    private offset;
-    composer: Composer;
-    constructor(bot: AnyBot, onError: CaughtMiddlewareHandler<Context<any>>);
-    handleUpdate(data: TelegramUpdate): Promise<void>;
-    /** @deprecated use bot.start instead @internal */
-    startPolling(params?: APIMethodParams<"getUpdates">): Promise<void>;
-    startFetchLoop(params?: APIMethodParams<"getUpdates">): Promise<void>;
-    stopPolling(): void;
-}

package/dist/updates.js

@@ -1,87 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Updates = void 0;
-const promises_1 = require("node:timers/promises");
-const contexts_1 = require("@gramio/contexts");
-const composer_1 = require("./composer");
-class Updates {
-    bot;
-    isStarted = false;
-    offset = 0;
-    composer;
-    constructor(bot, onError) {
-        this.bot = bot;
-        this.composer = new composer_1.Composer(onError);
-    }
-    async handleUpdate(data) {
-        const updateType = Object.keys(data).at(1);
-        this.offset = data.update_id + 1;
-        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,
-                // @ts-expect-error
-                payload: updatePayload,
-                type: updateType,
-                updateId: data.update_id,
-            });
-            if ("isEvent" in context && context.isEvent() && context.eventType) {
-                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,
-                    // @ts-expect-error
-                    type: context.eventType,
-                    updateId: data.update_id,
-                });
-            }
-            this.composer.compose(context);
-        }
-        catch (error) {
-            throw new Error(`[UPDATES] Update type ${updateType} not supported.`);
-        }
-    }
-    /** @deprecated use bot.start instead @internal */
-    async startPolling(params = {}) {
-        if (this.isStarted)
-            throw new Error("[UPDATES] Polling already started!");
-        this.isStarted = true;
-        this.startFetchLoop(params);
-        return;
-    }
-    async startFetchLoop(params = {}) {
-        while (this.isStarted) {
-            try {
-                const updates = await this.bot.api.getUpdates({
-                    ...params,
-                    offset: this.offset,
-                });
-                for await (const update of updates) {
-                    //TODO: update errors
-                    await this.handleUpdate(update).catch(console.error);
-                }
-            }
-            catch (error) {
-                console.error("Error received when fetching updates", error);
-                await promises_1.scheduler.wait(this.bot.options.api.retryGetUpdatesWait);
-            }
-        }
-    }
-    stopPolling() {
-        this.isStarted = false;
-    }
-}
-exports.Updates = Updates;

package/dist/webhook/adapters.d.ts

@@ -1,53 +0,0 @@
-import type { TelegramUpdate } from "@gramio/types";
-import type { MaybePromise } from "../types";
-export interface FrameworkHandler {
-    update: MaybePromise<TelegramUpdate>;
-    header: string;
-    unauthorized: () => unknown;
-    response?: () => unknown;
-}
-export type FrameworkAdapter = (...args: any[]) => FrameworkHandler;
-export declare const frameworks: {
-    elysia: ({ body, headers }: any) => {
-        update: any;
-        header: any;
-        unauthorized: () => import("bun-types/fetch").Response;
-    };
-    fastify: (request: any, reply: any) => {
-        update: any;
-        header: any;
-        unauthorized: () => any;
-    };
-    hono: (c: any) => {
-        update: any;
-        header: any;
-        unauthorized: () => any;
-    };
-    express: (req: any, res: any) => {
-        update: any;
-        header: any;
-        unauthorized: () => any;
-    };
-    koa: (ctx: any) => {
-        update: any;
-        header: any;
-        unauthorized: () => void;
-    };
-    http: (req: any, res: any) => {
-        update: Promise<TelegramUpdate>;
-        header: any;
-        unauthorized: () => any;
-    };
-    "std/http": (req: any) => {
-        update: any;
-        header: any;
-        response: () => import("bun-types/fetch").Response;
-        unauthorized: () => import("bun-types/fetch").Response;
-    };
-    "Bun.serve": (req: any) => {
-        update: any;
-        header: any;
-        response: () => import("bun-types/fetch").Response;
-        unauthorized: () => import("bun-types/fetch").Response;
-    };
-};

package/dist/webhook/adapters.js

@@ -1,58 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.frameworks = void 0;
-const SECRET_TOKEN_HEADER = "X-Telegram-Bot-Api-Secret-Token";
-const WRONG_TOKEN_ERROR = "secret token is invalid";
-exports.frameworks = {
-    elysia: ({ body, headers }) => ({
-        update: body,
-        header: headers[SECRET_TOKEN_HEADER],
-        unauthorized: () => new Response(WRONG_TOKEN_ERROR, { status: 401 }),
-    }),
-    fastify: (request, reply) => ({
-        update: request.body,
-        header: request.headers[SECRET_TOKEN_HEADER],
-        unauthorized: () => reply.code(401).send(WRONG_TOKEN_ERROR),
-    }),
-    hono: (c) => ({
-        update: c.req.json(),
-        header: c.req.header(SECRET_TOKEN_HEADER),
-        unauthorized: () => c.text(WRONG_TOKEN_ERROR, 401),
-    }),
-    express: (req, res) => ({
-        update: req.body,
-        header: req.header(SECRET_TOKEN_HEADER),
-        unauthorized: () => res.status(401).send(WRONG_TOKEN_ERROR),
-    }),
-    koa: (ctx) => ({
-        update: ctx.request.body,
-        header: ctx.get(SECRET_TOKEN_HEADER),
-        unauthorized: () => {
-            ctx.status === 401;
-            ctx.body = WRONG_TOKEN_ERROR;
-        },
-    }),
-    http: (req, res) => ({
-        update: new Promise((resolve) => {
-            let body = "";
-            req.on("data", (chunk) => {
-                body += chunk.toString();
-            });
-            req.on("end", () => resolve(JSON.parse(body)));
-        }),
-        header: req.headers[SECRET_TOKEN_HEADER.toLowerCase()],
-        unauthorized: () => res.writeHead(401).end(WRONG_TOKEN_ERROR),
-    }),
-    "std/http": (req) => ({
-        update: req.json(),
-        header: req.headers.get(SECRET_TOKEN_HEADER),
-        response: () => new Response("ok!"),
-        unauthorized: () => new Response(WRONG_TOKEN_ERROR, { status: 401 }),
-    }),
-    "Bun.serve": (req) => ({
-        update: req.json(),
-        header: req.headers.get(SECRET_TOKEN_HEADER),
-        response: () => new Response("ok!"),
-        unauthorized: () => new Response(WRONG_TOKEN_ERROR, { status: 401 }),
-    }),
-};

package/dist/webhook/index.d.ts

@@ -1,35 +0,0 @@
-import type { Bot } from "../bot";
-import { frameworks } from "./adapters";
-/** Union type of webhook handlers name */
-export type WebhookHandlers = keyof typeof frameworks;
-/**
- * Setup handler with yours web-framework to receive updates via webhook
- *
- *	@example
- * ```ts
- * import { Bot } from "gramio";
- * import Fastify from "fastify";
- *
- * const bot = new Bot(process.env.TOKEN as string).on(
- * 	"message",
- * 	(context) => {
- * 		return context.send("Fastify!");
- * 	},
- * );
- *
- * const fastify = Fastify();
- *
- * fastify.post("/telegram-webhook", webhookHandler(bot, "fastify"));
- *
- * fastify.listen({ port: 3445, host: "::" });
- *
- * bot.start({
- *     webhook: {
- *         url: "https://example.com:3445/telegram-webhook",
- *     },
- * });
- * ```
- */
-export declare function webhookHandler<Framework extends keyof typeof frameworks>(bot: Bot, framework: Framework, secretToken?: string): ReturnType<(typeof frameworks)[Framework]> extends {
-    response: () => any;
-} ? (...args: Parameters<(typeof frameworks)[Framework]>) => ReturnType<ReturnType<(typeof frameworks)[Framework]>["response"]> : (...args: Parameters<(typeof frameworks)[Framework]>) => void;

package/dist/webhook/index.js

@@ -1,46 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.webhookHandler = webhookHandler;
-const adapters_1 = require("./adapters");
-/**
- * Setup handler with yours web-framework to receive updates via webhook
- *
- *	@example
- * ```ts
- * import { Bot } from "gramio";
- * import Fastify from "fastify";
- *
- * const bot = new Bot(process.env.TOKEN as string).on(
- * 	"message",
- * 	(context) => {
- * 		return context.send("Fastify!");
- * 	},
- * );
- *
- * const fastify = Fastify();
- *
- * fastify.post("/telegram-webhook", webhookHandler(bot, "fastify"));
- *
- * fastify.listen({ port: 3445, host: "::" });
- *
- * bot.start({
- *     webhook: {
- *         url: "https://example.com:3445/telegram-webhook",
- *     },
- * });
- * ```
- */
-function webhookHandler(bot, framework, secretToken) {
-    const frameworkAdapter = adapters_1.frameworks[framework];
-    return (async (...args) => {
-        // @ts-expect-error
-        const { update, response, header, unauthorized } = frameworkAdapter(
-        // @ts-expect-error
-        ...args);
-        if (secretToken && header !== secretToken)
-            return unauthorized();
-        await bot.updates.handleUpdate(await update);
-        if (response)
-            return response();
-    });
-}