@effect-ak/tg-bot-client 0.0.4 → 0.0.7

package/dist/cjs/client/_client.js

@@ -15,7 +15,7 @@ const makeTgBotClient = inputConfig => {
   const execute = (0, _executeRequest.makeExecute)(config);
   const file = (0, _downloadFile.makeDownloadFile)(config, execute);
   return {
-    execute,
+    ...execute,
     ...file
   };
 };

package/dist/cjs/client/download-file.js

@@ -4,19 +4,38 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.makeDownloadFile = void 0;
+var _errors = require("./errors.js");
 const makeDownloadFile = (config, execute) => {
   const getFile = async input => {
-    const response = await execute("get_file", input);
-    response.result?.file_path;
-    const file_path = response.result?.file_path;
-    if (!file_path || file_path.length == 0) throw new Error("NoFilePath", {
-      cause: response
-    });
+    const response = await execute.execute("get_file", input);
+    if (response.error) return {
+      error: response.error
+    };
+    const file_path = response.success?.file_path;
+    if (!file_path || file_path.length == 0) {
+      return {
+        error: new _errors.TgBotClientError({
+          type: "UnableToGetFile",
+          cause: "File path not defined"
+        })
+      };
+    }
     const file_name = file_path.replaceAll("/", "-");
     const url = `${config.baseUrl}/file/bot${config.token}/${file_path}`;
-    const fileContent = await fetch(url).then(_ => _.arrayBuffer());
-    const file = new File([new Uint8Array(fileContent)], file_name);
-    return file;
+    try {
+      const fileContent = await fetch(url).then(_ => _.arrayBuffer());
+      const file = new File([new Uint8Array(fileContent)], file_name);
+      return {
+        success: file
+      };
+    } catch (cause) {
+      return {
+        error: new _errors.TgBotClientError({
+          type: "UnableToGetFile",
+          cause
+        })
+      };
+    }
   };
   return {
     getFile

package/dist/cjs/client/errors.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TgBotClientError = void 0;
+class TgBotClientError extends Error {
+  reason;
+  _tag = "TgBotClientError";
+  constructor(reason) {
+    super();
+    this.reason = reason;
+  }
+  static missingSuccess = new TgBotClientError({
+    type: "ClientInternalError",
+    cause: "Expected 'success' to be defined"
+  });
+}
+exports.TgBotClientError = TgBotClientError;

package/dist/cjs/client/execute-request.js

@@ -6,21 +6,58 @@ Object.defineProperty(exports, "__esModule", {
 exports.makeExecute = void 0;
 var _request = require("./request.js");
 var _response = require("./response.js");
+var _errors = require("./errors.js");
 const makeExecute = config => {
   const execute = async (method, input) => {
-    const httpResponse = await fetch(`${config.baseUrl}/bot${config.token}/${snakeToCamel(method)}`, {
-      body: (0, _request.makePayload)(input) ?? null,
-      method: "POST"
-    }).then(_ => _.json());
-    if (!(0, _response.isTgBotApiResponse)(httpResponse)) throw new Error("Not valid response", {
-      cause: httpResponse
-    });
-    if (httpResponse.ok == false) {
-      console.warn(httpResponse);
+    try {
+      const httpResponse = await fetch(`${config.baseUrl}/bot${config.token}/${snakeToCamel(method)}`, {
+        body: (0, _request.makePayload)(input) ?? null,
+        method: "POST"
+      });
+      const response = await httpResponse.json();
+      if (!(0, _response.isTgBotApiResponse)(response)) {
+        return {
+          error: new _errors.TgBotClientError({
+            type: "UnexpectedResponse",
+            response
+          })
+        };
+      }
+      if (!httpResponse.ok) {
+        return {
+          error: new _errors.TgBotClientError({
+            type: "NotOkResponse",
+            ...(response.error_code ? {
+              errorCode: response.error_code
+            } : undefined),
+            ...(response.description ? {
+              details: response.description
+            } : undefined)
+          })
+        };
+      }
+      return {
+        success: response.result
+      };
+    } catch (cause) {
+      return {
+        error: new _errors.TgBotClientError({
+          type: "ClientInternalError",
+          cause
+        })
+      };
     }
-    return httpResponse;
   };
-  return execute;
+  const unsafeExecute = async (method, input) => {
+    const result = await execute(method, input);
+    if (result.error) throw result.error;
+    if (!("success" in result)) throw _errors.TgBotClientError.missingSuccess;
+    return result.success;
+  };
+  return {
+    execute,
+    unsafeExecute
+  };
 };
 exports.makeExecute = makeExecute;
 const snakeToCamel = methodName => methodName.split("_").reduce((result, word, step) => {

package/dist/cjs/client/response.js

@@ -5,6 +5,18 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.isTgBotApiResponse = void 0;
 const isTgBotApiResponse = input => {
-  return "ok" in input && typeof input.ok == "boolean" && (typeof input.error_code === 'undefined' || typeof input.error_code === 'number') && (typeof input.description === 'undefined' || typeof input.description === 'string') && (typeof input.result === 'undefined' || typeof input.result === 'object');
+  if (typeof input !== "object" || input == null) {
+    return false;
+  }
+  if (!("ok" in input && typeof input.ok == "boolean")) {
+    return false;
+  }
+  if ("error_code" in input && typeof input.error_code != "number") {
+    return false;
+  }
+  if ("description" in input && typeof input.description != "string") {
+    return false;
+  }
+  return true;
 };
 exports.isTgBotApiResponse = isTgBotApiResponse;

package/dist/dts/client/_client.d.ts

@@ -7,6 +7,13 @@ export type TgBotClient = ReturnType<typeof makeTgBotClient>;
 export declare const makeTgBotClient: (inputConfig: SetOptional<BotConfig, "baseUrl">) => {
     readonly getFile: (input: {
         file_id: string;
-    }) => Promise<import("buffer").File>;
-    readonly execute: <M extends keyof import("../index.js").Api>(method: M, input: Parameters<import("../index.js").Api[M]>[0]) => Promise<import("./response.js").TgBotApiResponse<ReturnType<import("../index.js").Api[M]>>>;
+    }) => Promise<{
+        success?: File;
+        error?: import("./errors.js").TgBotClientError;
+    }>;
+    readonly execute: <M extends keyof import("../index.js").Api>(method: M, input: Parameters<import("../index.js").Api[M]>[0]) => Promise<{
+        success?: ReturnType<import("../index.js").Api[M]>;
+        error?: import("./errors.js").TgBotClientError;
+    }>;
+    readonly unsafeExecute: <M extends keyof import("../index.js").Api>(method: M, input: Parameters<import("../index.js").Api[M]>[0]) => Promise<ReturnType<import("../index.js").Api[M]>>;
 };

package/dist/dts/client/download-file.d.ts

@@ -1,7 +1,13 @@
 import type { BotConfig } from "./_client.js";
+import { TgBotClientError } from "./errors.js";
 import type { ExecuteRequest } from "./execute-request.js";
+type GetFileResult = {
+    success?: File;
+    error?: TgBotClientError;
+};
 export declare const makeDownloadFile: (config: BotConfig, execute: ExecuteRequest) => {
     readonly getFile: (input: {
         file_id: string;
-    }) => Promise<import("buffer").File>;
+    }) => Promise<GetFileResult>;
 };
+export {};

package/dist/dts/client/errors.d.ts

@@ -0,0 +1,21 @@
+type ErrorReason = {
+    readonly type: "NotOkResponse";
+    readonly errorCode?: number;
+    readonly details?: string;
+} | {
+    readonly type: "UnexpectedResponse";
+    readonly response: unknown;
+} | {
+    readonly type: "ClientInternalError";
+    readonly cause: unknown;
+} | {
+    readonly type: "UnableToGetFile";
+    readonly cause: unknown;
+};
+export declare class TgBotClientError extends Error {
+    readonly reason: ErrorReason;
+    readonly _tag = "TgBotClientError";
+    constructor(reason: ErrorReason);
+    static readonly missingSuccess: TgBotClientError;
+}
+export {};

package/dist/dts/client/execute-request.d.ts

@@ -1,5 +1,13 @@
 import type { BotConfig } from "./_client.js";
 import type { Api } from "../specification/api.js";
-import { TgBotApiResponse } from "./response.js";
+import { TgBotClientError } from "./errors.js";
 export type ExecuteRequest = ReturnType<typeof makeExecute>;
-export declare const makeExecute: (config: BotConfig) => <M extends keyof Api>(method: M, input: Parameters<Api[M]>[0]) => Promise<TgBotApiResponse<ReturnType<Api[M]>>>;
+type SafeExecuteResult<M extends keyof Api> = {
+    success?: ReturnType<Api[M]>;
+    error?: TgBotClientError;
+};
+export declare const makeExecute: (config: BotConfig) => {
+    readonly execute: <M extends keyof Api>(method: M, input: Parameters<Api[M]>[0]) => Promise<SafeExecuteResult<M>>;
+    readonly unsafeExecute: <M extends keyof Api>(method: M, input: Parameters<Api[M]>[0]) => Promise<ReturnType<Api[M]>>;
+};
+export {};

package/dist/dts/client/request.d.ts

@@ -1 +1 @@
-export declare const makePayload: (body: Record<string, unknown>) => FormData | undefined;
+export declare const makePayload: (body: object) => FormData | undefined;

package/dist/dts/client/response.d.ts

@@ -4,4 +4,4 @@ export type TgBotApiResponse<O> = {
     description?: string;
     result?: O;
 };
-export declare const isTgBotApiResponse: <O>(input: Record<string, unknown>) => input is TgBotApiResponse<O>;
+export declare const isTgBotApiResponse: <O>(input: unknown) => input is TgBotApiResponse<O>;