@effect-ak/tg-bot-client 0.2.1 → 0.2.3

package/dist/index.js

@@ -0,0 +1,483 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  BotFactoryService: () => BotFactoryService,
+  BotFactoryServiceDefault: () => BotFactoryServiceDefault,
+  MESSAGE_EFFECTS: () => MESSAGE_EFFECTS,
+  defaultBaseUrl: () => defaultBaseUrl,
+  isMessageEffect: () => isMessageEffect,
+  makeTgBotClient: () => makeTgBotClient,
+  messageEffectIdCodes: () => messageEffectIdCodes,
+  runTgChatBot: () => runTgChatBot
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/client/_client.ts
+var Micro5 = __toESM(require("effect/Micro"));
+
+// src/client/config.ts
+var Context = __toESM(require("effect/Context"));
+
+// src/const.ts
+var defaultBaseUrl = "https://api.telegram.org";
+var MESSAGE_EFFECTS = {
+  "\u{1F525}": "5104841245755180586",
+  "\u{1F44D}": "5107584321108051014",
+  "\u{1F44E}": "5104858069142078462",
+  "\u2764\uFE0F": "5159385139981059251",
+  "\u{1F389}": "5046509860389126442",
+  "\u{1F4A9}": "5046589136895476101"
+};
+var messageEffectIdCodes = Object.keys(MESSAGE_EFFECTS);
+var isMessageEffect = (input) => {
+  return typeof input === "string" && input in MESSAGE_EFFECTS;
+};
+
+// src/client/config.ts
+var makeTgBotClientConfig = (input) => TgBotClientConfig.of({
+  ...input,
+  ["base-url"]: input["base-url"] ?? defaultBaseUrl
+});
+var TgBotClientConfig = class extends Context.Tag("TgBotClientConfig")() {
+};
+
+// src/client/execute-request/_service.ts
+var Micro2 = __toESM(require("effect/Micro"));
+var Context2 = __toESM(require("effect/Context"));
+
+// src/client/execute-request/execute.ts
+var Micro = __toESM(require("effect/Micro"));
+var String = __toESM(require("effect/String"));
+
+// src/client/errors.ts
+var Data = __toESM(require("effect/Data"));
+var TgBotClientError = class _TgBotClientError extends Data.TaggedError("TgBotClientError") {
+  static missingSuccess = new _TgBotClientError({
+    reason: {
+      type: "ClientInternalError",
+      cause: "Expected 'success' to be defined"
+    }
+  });
+};
+
+// src/client/guards.ts
+var isFileContent = (input) => typeof input == "object" && input != null && ("file_content" in input && input.file_content instanceof Uint8Array) && ("file_name" in input && typeof input.file_name == "string");
+var isTgBotApiResponse = (input) => typeof input == "object" && input != null && ("ok" in input && typeof input.ok == "boolean");
+var isTgBotClientSettingsInput = (input) => typeof input == "object" && input != null && ("bot-token" in input && typeof input["bot-token"] == "string");
+
+// src/client/execute-request/payload.ts
+var makePayload = (body) => {
+  const entries = Object.entries(body);
+  if (entries.length == 0) return void 0;
+  const result = new FormData();
+  for (const [key, value] of entries) {
+    if (!value) continue;
+    if (typeof value != "object") {
+      result.append(key, `${value}`);
+    } else if (isFileContent(value)) {
+      result.append(key, new Blob([value.file_content]), value.file_name);
+    } else {
+      result.append(key, JSON.stringify(value));
+    }
+  }
+  return result;
+};
+
+// src/client/execute-request/execute.ts
+var execute = (config, method, input) => Micro.gen(function* () {
+  const httpResponse = yield* Micro.tryPromise({
+    try: () => fetch(
+      `${config["base-url"]}/bot${config["bot-token"]}/${String.snakeToCamel(method)}`,
+      {
+        body: makePayload(input) ?? null,
+        method: "POST"
+      }
+    ),
+    catch: (cause) => new TgBotClientError({
+      reason: { type: "ClientInternalError", cause }
+    })
+  });
+  const response = yield* Micro.tryPromise({
+    try: () => httpResponse.json(),
+    catch: () => new TgBotClientError({
+      reason: { type: "UnexpectedResponse", response: httpResponse }
+    })
+  });
+  if (!isTgBotApiResponse(response)) {
+    return yield* Micro.fail(new TgBotClientError({
+      reason: { type: "UnexpectedResponse", response }
+    }));
+  }
+  if (!httpResponse.ok) {
+    return yield* Micro.fail(new TgBotClientError({
+      reason: {
+        type: "NotOkResponse",
+        ...response.error_code ? { errorCode: response.error_code } : void 0,
+        ...response.description ? { details: response.description } : void 0
+      }
+    }));
+  }
+  return response.result;
+});
+
+// src/client/execute-request/_service.ts
+var ClientExecuteRequestService = class extends Context2.Tag("ClientExecuteRequestService")() {
+};
+var ClientExecuteRequestServiceDefault = Micro2.gen(function* () {
+  const config = yield* Micro2.service(TgBotClientConfig);
+  return {
+    execute: (method, input) => execute(config, method, input)
+  };
+});
+
+// src/client/file/_service.ts
+var Micro4 = __toESM(require("effect/Micro"));
+var Context3 = __toESM(require("effect/Context"));
+
+// src/client/file/get-file.ts
+var Micro3 = __toESM(require("effect/Micro"));
+var getFile = (fileId, config, execute2) => Micro3.gen(function* () {
+  const response = yield* execute2.execute("get_file", { file_id: fileId });
+  const file_path = response.file_path;
+  if (!file_path || file_path.length == 0) {
+    return yield* Micro3.fail(
+      new TgBotClientError({
+        reason: {
+          type: "UnableToGetFile",
+          cause: "File path not defined"
+        }
+      })
+    );
+  }
+  const file_name = file_path.replaceAll("/", "-");
+  const url = `${config["base-url"]}/file/bot${config["bot-token"]}/${file_path}`;
+  const fileContent = yield* Micro3.tryPromise({
+    try: () => fetch(url).then((_) => _.arrayBuffer()),
+    catch: (cause) => new TgBotClientError({
+      reason: { type: "UnableToGetFile", cause }
+    })
+  });
+  const file = new File([new Uint8Array(fileContent)], file_name);
+  return file;
+});
+
+// src/client/file/_service.ts
+var ClientFileService = class extends Context3.Tag("ClientFileService")() {
+};
+var ClientFileServiceDefault = Micro4.gen(function* () {
+  const config = yield* Micro4.service(TgBotClientConfig);
+  const execute2 = yield* Micro4.service(ClientExecuteRequestService);
+  return {
+    getFile: (input) => getFile(input.file_id, config, execute2)
+  };
+}).pipe(
+  Micro4.provideServiceEffect(ClientExecuteRequestService, ClientExecuteRequestServiceDefault)
+);
+
+// src/client/_client.ts
+var makeTgBotClient = (input) => {
+  const config = makeTgBotClientConfig(input);
+  const client = Micro5.gen(function* () {
+    const execute2 = yield* Micro5.service(ClientExecuteRequestService);
+    const file = yield* Micro5.service(ClientFileService);
+    return {
+      execute: (method, input2) => execute2.execute(method, input2).pipe(Micro5.runPromise),
+      getFile: (input2) => file.getFile(input2).pipe(Micro5.runPromise)
+    };
+  }).pipe(
+    Micro5.provideServiceEffect(ClientExecuteRequestService, ClientExecuteRequestServiceDefault),
+    Micro5.provideServiceEffect(ClientFileService, ClientFileServiceDefault),
+    Micro5.provideService(TgBotClientConfig, config),
+    Micro5.runSync
+  );
+  return client;
+};
+
+// src/bot/run.ts
+var Micro12 = __toESM(require("effect/Micro"));
+
+// src/bot/factory/_service.ts
+var Micro11 = __toESM(require("effect/Micro"));
+var Context5 = __toESM(require("effect/Context"));
+
+// src/bot/update-poller/_service.ts
+var Micro8 = __toESM(require("effect/Micro"));
+var Context4 = __toESM(require("effect/Context"));
+
+// src/bot/update-poller/poll-and-handle.ts
+var Micro7 = __toESM(require("effect/Micro"));
+
+// src/bot/update-poller/settings.ts
+var makeSettingsFrom = (input) => {
+  let limit = input.batch_size ?? 10;
+  let timeout = input.timeout ?? 10;
+  let max_empty_responses = input.max_empty_responses;
+  if (limit < 10 || limit > 100) {
+    console.warn("Wrong limit, must be in [10..100], using 10 instead");
+    limit = 10;
+  }
+  if (timeout < 2 || timeout > 10) {
+    console.warn("Wrong timeout, must be in [2..10], using 2 instead");
+    limit = 10;
+  }
+  if (max_empty_responses && max_empty_responses < 2) {
+    console.warn("Wrong max_empty_responses, must be in [2..infinity], using infinity");
+    max_empty_responses = void 0;
+  }
+  return {
+    limit,
+    timeout,
+    max_empty_responses
+  };
+};
+
+// src/bot/update-poller/fetch-updates.ts
+var Micro6 = __toESM(require("effect/Micro"));
+
+// src/bot/message-handler/utils.ts
+var extractUpdate = (input) => {
+  for (const [field, value] of Object.entries(input)) {
+    if (field == "update_id") {
+      continue;
+    }
+    return {
+      type: field,
+      ...value
+    };
+  }
+  return void 0;
+};
+
+// src/bot/update-poller/fetch-updates.ts
+var fetchUpdates = ({ state, settings, execute: execute2, handlers }) => Micro6.gen(function* () {
+  const updateId = state.lastUpdateId;
+  console.info("getting updates", state);
+  const updates = yield* execute2("get_updates", {
+    ...settings,
+    ...updateId ? { offset: updateId } : void 0
+  }).pipe(
+    Micro6.andThen((_) => _.sort((_2) => _2.update_id))
+  );
+  let lastSuccessId = void 0;
+  let hasError = false;
+  for (const updateObject of updates) {
+    const update = extractUpdate(updateObject);
+    if (!update) {
+      console.warn("Unknown update", update);
+      hasError = true;
+      break;
+    }
+    const handler = handlers[`on_${update.type}`];
+    if (!handler) {
+      console.warn("Handler for update not defined", update);
+      hasError = true;
+      break;
+    }
+    const handleResult = handler(update);
+    if ("chat" in update) {
+      const response = yield* execute2(`send_${handleResult.type}`, {
+        ...handleResult,
+        chat_id: update.chat.id
+      });
+      console.log("bot response", response);
+    }
+    if (!handleResult) {
+      hasError = true;
+      console.log(handleResult);
+      break;
+    }
+    ;
+    lastSuccessId = updateObject.update_id;
+  }
+  if (hasError && lastSuccessId) {
+    const resp = (
+      //commit successfully handled messages
+      yield* execute2("get_updates", {
+        offset: lastSuccessId,
+        limit: 0
+      })
+    );
+  }
+  return { updates, lastSuccessId, hasError };
+});
+
+// src/bot/update-poller/poll-and-handle.ts
+var pollAndHandle = (input) => {
+  const state = {
+    lastUpdateId: void 0,
+    emptyResponses: 0
+  };
+  const settings = makeSettingsFrom(input.settings);
+  return Micro7.delay(1e3)(
+    fetchUpdates({
+      state,
+      settings,
+      execute: input.execute,
+      handlers: input.settings
+    })
+  ).pipe(
+    Micro7.repeat({
+      while: ({ updates, lastSuccessId, hasError }) => {
+        if (hasError) {
+          console.warn("error in handler, quitting");
+          return false;
+        }
+        if (updates.length == 0) {
+          state.emptyResponses += 1;
+          if (settings.max_empty_responses && state.emptyResponses > settings.max_empty_responses) {
+            console.info("too many empty responses, quitting");
+            return false;
+          }
+        } else {
+          state.emptyResponses = 0;
+        }
+        ;
+        if (lastSuccessId) {
+          state.lastUpdateId = lastSuccessId + 1;
+        }
+        return true;
+      }
+    })
+  );
+};
+
+// src/bot/update-poller/_service.ts
+var BotUpdatePollerService = class extends Context4.Tag("BotUpdatePollerService")() {
+};
+var BotUpdatesPollerServiceDefault = Micro8.gen(function* () {
+  console.log("Initiating BotUpdatesPollerServiceDefault");
+  const state = {
+    fiber: void 0
+  };
+  const client = yield* Micro8.service(ClientExecuteRequestService);
+  const runBot = (messageHandler) => Micro8.gen(function* () {
+    console.log(state);
+    const startFiber = pollAndHandle({
+      settings: messageHandler,
+      execute: client.execute
+    }).pipe(
+      Micro8.forkDaemon,
+      Micro8.tap(
+        (fiber) => fiber.addObserver((exit) => {
+          console.log("bot's fiber has been closed", exit);
+          if (messageHandler.onExit) {
+            messageHandler.onExit(exit);
+          }
+        })
+      )
+    );
+    if (state.fiber) {
+      console.log("killing previous bot's fiber");
+      yield* Micro8.fiberInterrupt(state.fiber);
+    }
+    state.fiber = yield* startFiber;
+    console.log("Reading bot's updates.....", state.fiber == null);
+    return state.fiber;
+  });
+  return {
+    runBot
+  };
+}).pipe(
+  Micro8.provideServiceEffect(ClientExecuteRequestService, ClientExecuteRequestServiceDefault)
+);
+
+// src/bot/factory/client-config.ts
+var Micro9 = __toESM(require("effect/Micro"));
+var makeClientConfigFrom = (input) => Micro9.gen(function* () {
+  if (input.type == "config") {
+    return makeTgBotClientConfig(input);
+  }
+  const config = yield* Micro9.tryPromise({
+    try: async () => {
+      const { readFileSync } = await import("fs");
+      return JSON.parse(await readFileSync("config.json", "utf-8"));
+    },
+    catch: (error) => {
+      console.warn(error);
+      return "ReadingConfigError";
+    }
+  });
+  if (!isTgBotClientSettingsInput(config)) {
+    return yield* Micro9.fail("InvalidConfig");
+  }
+  return makeTgBotClientConfig(config);
+});
+
+// src/bot/factory/make-bot.ts
+var Micro10 = __toESM(require("effect/Micro"));
+var makeBot = (messageHandler) => Micro10.gen(function* () {
+  const { runBot } = yield* Micro10.service(BotUpdatePollerService);
+  return {
+    fiber: yield* runBot(messageHandler),
+    runBot
+  };
+}).pipe(
+  Micro10.tapError((error) => {
+    console.error(error);
+    return Micro10.void;
+  })
+);
+
+// src/bot/factory/_service.ts
+var BotFactoryService = class extends Context5.Tag("BotFactoryService")() {
+};
+var BotFactoryServiceDefault = {
+  makeBot,
+  runBot: (input) => Micro11.gen(function* () {
+    console.log("client");
+    const client = yield* makeClientConfigFrom(input);
+    const poller = yield* BotUpdatesPollerServiceDefault.pipe(
+      Micro11.provideService(TgBotClientConfig, client)
+    );
+    const bot = yield* makeBot(input).pipe(
+      Micro11.provideService(BotUpdatePollerService, poller)
+    );
+    const reload = (input2) => bot.runBot(input2).pipe(Micro11.runPromise);
+    return {
+      reload
+    };
+  })
+};
+
+// src/bot/run.ts
+var runTgChatBot = (input) => BotFactoryServiceDefault.runBot(input).pipe(Micro12.runPromise);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BotFactoryService,
+  BotFactoryServiceDefault,
+  MESSAGE_EFFECTS,
+  defaultBaseUrl,
+  isMessageEffect,
+  makeTgBotClient,
+  messageEffectIdCodes,
+  runTgChatBot
+});