gramio 0.0.2 → 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/package.json

@@ -1,6 +1,6 @@
 {
     "name": "gramio",
-    "version": "0.0.2",
+    "version": "0.0.3",
     "description": "WIP",
     "main": "./dist/index.js",
     "types": "./dist/index.d.ts",