gramio 0.0.1 → 0.0.3

package/dist/apiErrors.d.ts

@@ -0,0 +1,12 @@
+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);
+}

package/dist/apiErrors.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APIError = void 0;
+//TODO: more elegant
+class APIError extends Error {
+    method;
+    params;
+    code;
+    payload;
+    constructor({ method, params }, error) {
+        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;

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+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;
+    updates: Updates;
+    private _callApi;
+    constructor(token: string, options?: Omit<BotOptions, "token">);
+}
+export * from "@gramio/types";

package/dist/index.js

@@ -0,0 +1,71 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Bot = void 0;
+const files_1 = require("@gramio/files");
+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 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);
+    async _callApi(method, params = {}) {
+        const url = `https://api.telegram.org/bot${this.options.token}/${method}`;
+        const reqOptions = {
+            method: "POST",
+            duplex: "half",
+        };
+        if ((0, files_1.isMediaUpload)(method, params)) {
+            const formData = await (0, files_1.convertJsonToFormData)(method, params);
+            const encoder = new form_data_encoder_1.FormDataEncoder(formData);
+            reqOptions.body = encoder.encode();
+            reqOptions.headers = encoder.headers;
+        }
+        else {
+            reqOptions.headers = {
+                "Content-Type": "application/json",
+            };
+            reqOptions.body = JSON.stringify(params);
+        }
+        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);
+        return data.result;
+    }
+    constructor(token, options) {
+        this.options = { ...options, token };
+    }
+};
+exports.Bot = Bot;
+exports.Bot = Bot = __decorate([
+    (0, inspectable_1.Inspectable)({
+        serialize: () => ({}),
+    })
+], Bot);
+__exportStar(require("@gramio/types"), exports);

package/dist/types.d.ts

@@ -0,0 +1,7 @@
+import { contextsMappings } from "@gramio/contexts";
+import { NextMiddleware } from "middleware-io";
+export interface BotOptions {
+    token?: string;
+}
+export type THandler<T> = (context: T, next: NextMiddleware) => unknown;
+export type UpdateNames = keyof typeof contextsMappings;

package/dist/types.js

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

package/dist/updates.d.ts

@@ -0,0 +1,17 @@
+import { Context, contextsMappings } from "@gramio/contexts";
+import type { TelegramUpdate } from "@gramio/types";
+import { Bot } from ".";
+import { THandler, UpdateNames } 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;
+    handleUpdate(data: TelegramUpdate): Promise<void>;
+    startPolling(): Promise<null>;
+    startFetchLoop(): Promise<void>;
+    stopPolling(): void;
+}

package/dist/updates.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Updates = void 0;
+const contexts_1 = require("@gramio/contexts");
+const middleware_io_1 = require("middleware-io");
+class Updates {
+    bot;
+    isStarted = false;
+    offset = 0;
+    composer = middleware_io_1.Composer.builder();
+    constructor(bot) {
+        this.bot = bot;
+    }
+    on(updateName, handler) {
+        return this.use((context, next) => {
+            //TODO: fix typings
+            if (context.is(updateName))
+                handler(context, next);
+            else
+                next();
+        });
+    }
+    use(handler) {
+        this.composer.use(handler);
+        return this;
+    }
+    async handleUpdate(data) {
+        const updateType = Object.keys(data).at(1);
+        this.offset = data.update_id + 1;
+        try {
+            const context = new contexts_1.contextsMappings[updateType]({
+                bot: this.bot,
+                update: data,
+                //TODO: fix
+                //@ts-ignore
+                payload: data[updateType],
+                type: updateType,
+                updateId: data.update_id,
+                // raw: {
+                // 	update: data,
+                // 	updateId: data.update_id,
+                // 	updateType,
+                // },
+            });
+            this.composer.compose()(
+            //TODO: fix typings
+            context, middleware_io_1.noopNext);
+        }
+        catch (error) {
+            throw new Error(`Update type ${updateType} not supported.`);
+        }
+    }
+    async startPolling() {
+        if (this.isStarted)
+            throw new Error("[UPDATES] Polling already started!");
+        this.isStarted = true;
+        this.startFetchLoop();
+        return null;
+    }
+    async startFetchLoop() {
+        while (this.isStarted) {
+            const updates = await this.bot.api.getUpdates({
+                offset: this.offset,
+            });
+            for await (const update of updates) {
+                //TODO: update errors
+                await this.handleUpdate(update).catch(console.error);
+            }
+        }
+    }
+    stopPolling() {
+        this.isStarted = false;
+    }
+}
+exports.Updates = Updates;

package/package.json

@@ -1,27 +1,29 @@
 {
     "name": "gramio",
-    "version": "0.0.1",
-    "description": "",
+    "version": "0.0.3",
+    "description": "WIP",
     "main": "./dist/index.js",
+    "types": "./dist/index.d.ts",
     "scripts": {
-        "imports": "ts-node ./scripts/generate-imports.ts",
-        "lint": "eslint \"src/**/*.{js,ts}\"",
-        "lint:fix": "eslint \"src/**/*.{js,ts}\" --fix"
+        "lint": "bun check ./src",
+        "lint:fix": "bun lint --apply"
     },
     "author": "kravets",
     "license": "ISC",
     "devDependencies": {
-        "@gramio/types": "^7.0.6",
-        "@types/node": "^20.8.9",
-        "eslint": "^8.52.0",
-        "eslint-kit": "^10.6.0",
-        "prettier": "^3.0.3"
+        "@biomejs/biome": "1.5.3",
+        "@gramio/types": "^7.0.14",
+        "@types/node": "^20.11.17"
     },
     "dependencies": {
+        "@gramio/contexts": "^0.0.1",
+        "form-data-encoder": "^4.0.2",
         "inspectable": "^2.1.0",
         "middleware-io": "^2.8.1",
-        "reflect-metadata": "^0.1.13",
-        "undici": "^5.27.0"
+        "reflect-metadata": "^0.2.1",
+        "undici": "^6.6.2"
     },
-    "files": []
+    "files": [
+        "dist"
+    ]
 }