@effect-ak/tg-bot-client 0.3.2 → 0.4.0

package/dist/index.mjs

@@ -1,12 +1,17 @@
 // src/bot/factory/_service.ts
-import * as Micro7 from "effect/Micro";
-import * as Context3 from "effect/Context";
+import * as Micro6 from "effect/Micro";
+import * as Context4 from "effect/Context";
+
+// src/bot/message-handler/_service.ts
+import * as Context from "effect/Context";
+var BotMessageHandler = class extends Context.Tag("BotMessageHandler")() {
+};
 
 // src/bot/update-poller/_service.ts
 import * as Micro4 from "effect/Micro";
-import * as Context2 from "effect/Context";
+import * as Context3 from "effect/Context";
 
-// src/bot/update-poller/poll-and-handle.ts
+// src/bot/update-poller/poll-updates.ts
 import * as Micro3 from "effect/Micro";
 
 // src/bot/update-poller/settings.ts
@@ -14,8 +19,8 @@ var makeSettingsFrom = (input) => {
   let limit = input.batch_size ?? 10;
   let timeout = input.timeout ?? 10;
   let max_empty_responses = input.max_empty_responses;
-  let update_types = input.update_types;
   let log_level = input.log_level;
+  let on_error = input.on_error;
   if (limit < 10 || limit > 100) {
     console.warn("Wrong limit, must be in [10..100], using 10 instead");
     limit = 10;
@@ -32,24 +37,35 @@ var makeSettingsFrom = (input) => {
     console.warn("Wrong max_empty_responses, must be in [2..infinity], using infinity");
     max_empty_responses = void 0;
   }
-  if (!update_types) {
-    console.info("Handling only messages, ignoring others");
-    update_types = ["message"];
-  }
   if (!log_level) {
     log_level = "info";
   }
-  return {
+  if (!on_error) {
+    on_error = "stop";
+  }
+  const config = {
     limit,
     timeout,
     max_empty_responses,
-    update_types,
-    log_level
+    log_level,
+    on_error
   };
+  console.log("bot configuration", config);
+  return config;
 };
 
-// src/bot/update-poller/fetch-updates.ts
+// src/bot/update-poller/fetch-and-handle.ts
 import * as Micro2 from "effect/Micro";
+import * as Data from "effect/Data";
+
+// src/bot/message-handler/types.ts
+import { TaggedClass } from "effect/Data";
+var BotResponse = class _BotResponse extends TaggedClass("BotResponse") {
+  static make(result) {
+    return new _BotResponse({ response: result });
+  }
+  static ignore = new _BotResponse({});
+};
 
 // src/bot/message-handler/utils.ts
 var extractUpdate = (input) => {
@@ -70,8 +86,8 @@ import * as Micro from "effect/Micro";
 import * as String from "effect/String";
 
 // src/client/errors.ts
-import * as Data from "effect/Data";
-var TgBotClientError = class _TgBotClientError extends Data.TaggedError("TgBotClientError") {
+import { TaggedError } from "effect/Data";
+var TgBotClientError = class _TgBotClientError extends TaggedError("TgBotClientError") {
   static missingSuccess = new _TgBotClientError({
     reason: {
       type: "ClientInternalError",
@@ -81,7 +97,7 @@ var TgBotClientError = class _TgBotClientError extends Data.TaggedError("TgBotCl
 };
 
 // src/client/config.ts
-import * as Context from "effect/Context";
+import * as Context2 from "effect/Context";
 
 // src/const.ts
 var defaultBaseUrl = "https://api.telegram.org";
@@ -103,7 +119,7 @@ var makeTgBotClientConfig = (input) => TgBotClientConfig.of({
   ...input,
   base_url: input.base_url ?? defaultBaseUrl
 });
-var TgBotClientConfig = class extends Context.Tag("TgBotClientConfig")() {
+var TgBotClientConfig = class extends Context2.Tag("TgBotClientConfig")() {
 };
 
 // src/client/guards.ts
@@ -167,8 +183,10 @@ var execute = (method, input) => Micro.gen(function* () {
   return response.result;
 });
 
-// src/bot/update-poller/fetch-updates.ts
-var fetchUpdates = ({ state, settings, handlers }) => Micro2.gen(function* () {
+// src/bot/update-poller/fetch-and-handle.ts
+var HandleUpdateError = class extends Data.TaggedError("HandleUpdateError") {
+};
+var fetchAndHandle = ({ state, settings, handlers }) => Micro2.gen(function* () {
   const updateId = state.lastUpdateId;
   if (settings.log_level == "debug") {
     console.debug("getting updates", state);
@@ -179,82 +197,146 @@ var fetchUpdates = ({ state, settings, handlers }) => Micro2.gen(function* () {
   }).pipe(
     Micro2.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) {
-      if (settings.update_types.includes(update.type)) {
-        console.error("Handler for update not defined", update);
-        hasError = true;
-        break;
-      } else {
-        if (settings.log_level == "debug") {
-          console.debug("Ignored update", update);
-        }
-        lastSuccessId = updateObject.update_id;
-        continue;
-      }
-    }
-    if (update.type == "message" && "text" in update) {
-      console.info("Got new message", {
-        chatId: update.chat.id,
-        chatType: update.chat.type,
-        message: `${update.text.slice(0, 5)}...`
-      });
-    }
-    const handleResult = handler(update);
-    if ("chat" in update && handleResult) {
-      const response = yield* execute(`send_${handleResult.type}`, {
-        ...handleResult,
-        chat_id: update.chat.id
-      });
-      if (settings.log_level == "debug" && "text") {
-        console.debug("bot response", response);
-      }
-    }
-    if (!handleResult && settings.log_level == "debug") {
-      console.debug("handler returned no response for update", { update });
-    }
-    ;
-    lastSuccessId = updateObject.update_id;
+  if (updates.length) {
+    console.debug(`got a batch of updates (${updates.length})`);
   }
-  if (hasError && lastSuccessId) {
+  const lastUpdateId = updates.map((_) => _.update_id).sort().at(-1);
+  if (!lastUpdateId) return { updates: [], lastUpdateId: void 0 };
+  const hasError = yield* Micro2.forEach(
+    updates,
+    (update) => handleUpdate(update, settings, handlers).pipe(
+      Micro2.catchAll((error) => {
+        console.log("error", {
+          updateId: update.update_id,
+          updateKey: Object.keys(update).at(1),
+          name: error._tag
+        });
+        return Micro2.succeed(true);
+      })
+    ),
+    {
+      concurrency: 10
+    }
+  ).pipe(
+    Micro2.andThen((result) => result.every((error) => error == null))
+  );
+  if (lastUpdateId) {
     yield* execute("get_updates", {
-      offset: lastSuccessId,
+      offset: lastUpdateId,
       limit: 0
     });
     if (settings.log_level == "debug") {
-      console.debug("committed offset", lastSuccessId);
+      console.debug("committed offset", lastUpdateId);
     }
   }
-  return { updates, lastSuccessId, hasError };
+  return { updates, lastUpdateId, hasError };
+});
+var handleUpdate = (updateObject, settings, handlers) => Micro2.gen(function* () {
+  const update = extractUpdate(updateObject);
+  if (!update) {
+    return yield* Micro2.fail(
+      new HandleUpdateError({
+        name: "UnknownUpdate",
+        update: updateObject
+      })
+    );
+  }
+  const handler = handlers[`on_${update.type}`];
+  if (!handler) {
+    return yield* Micro2.fail(
+      new HandleUpdateError({
+        name: "HandlerNotDefined",
+        update: updateObject
+      })
+    );
+  }
+  if (update.type == "message" && "text" in update) {
+    console.info("Got a new text message", {
+      chatId: update.chat.id,
+      chatType: update.chat.type,
+      message: `${update.text.slice(0, 5)}...`
+    });
+  }
+  let handleUpdateError;
+  const handleResult = yield* Micro2.try({
+    try: () => handler(update),
+    catch: (error) => new HandleUpdateError({
+      name: "BotHandlerError",
+      update: updateObject,
+      cause: error
+    })
+  }).pipe(
+    Micro2.andThen((handleResult2) => {
+      if (handleResult2 instanceof Promise) {
+        return Micro2.tryPromise({
+          try: () => handleResult2,
+          catch: (error) => new HandleUpdateError({
+            name: "BotHandlerError",
+            update: updateObject,
+            cause: error
+          })
+        });
+      }
+      return Micro2.succeed(handleResult2);
+    }),
+    Micro2.catchAll((error) => {
+      handleUpdateError = error;
+      return Micro2.succeed(
+        BotResponse.make({
+          type: "message",
+          text: `Some internal error has happend(${error.name}) while handling this message`,
+          message_effect_id: MESSAGE_EFFECTS["\u{1F4A9}"],
+          ...updateObject.message?.message_id ? {
+            reply_parameters: {
+              message_id: updateObject.message?.message_id
+            }
+          } : void 0,
+          reply_markup: {
+            inline_keyboard: [
+              [
+                { text: "Repeat", callback_data: "fix:123" }
+              ]
+            ]
+          }
+        })
+      );
+    })
+  );
+  if (!handleResult && settings.log_level == "debug") {
+    console.log(`Bot response is undefined for update with ID #${updateObject.update_id}.`);
+    return;
+  }
+  ;
+  if ("chat" in update && handleResult.response) {
+    const response = yield* execute(`send_${handleResult.response.type}`, {
+      ...handleResult.response,
+      chat_id: update.chat.id
+    });
+    if (settings.log_level == "debug" && "text") {
+      console.debug("bot response", response);
+    }
+  }
+  return handleUpdateError;
 });
 
-// src/bot/update-poller/poll-and-handle.ts
-var pollAndHandle = (input) => {
+// src/bot/update-poller/poll-updates.ts
+var pollUpdates = (input) => {
   const state = {
     lastUpdateId: void 0,
     emptyResponses: 0
   };
   const settings = makeSettingsFrom(input.settings);
   return Micro3.delay(1e3)(
-    fetchUpdates({
+    fetchAndHandle({
       state,
       settings,
       handlers: input.settings
     })
   ).pipe(
     Micro3.repeat({
-      while: ({ updates, lastSuccessId, hasError }) => {
-        if (hasError) {
-          console.info("error in handler, quitting");
+      while: ({ updates, lastUpdateId, hasError }) => {
+        if (hasError === true && settings.on_error == "stop") {
+          console.info("Could not handle some messages, quitting");
           return false;
         }
         if (updates.length == 0) {
@@ -267,8 +349,8 @@ var pollAndHandle = (input) => {
           state.emptyResponses = 0;
         }
         ;
-        if (lastSuccessId) {
-          state.lastUpdateId = lastSuccessId + 1;
+        if (lastUpdateId) {
+          state.lastUpdateId = lastUpdateId + 1;
         }
         return true;
       }
@@ -277,24 +359,23 @@ var pollAndHandle = (input) => {
 };
 
 // src/bot/update-poller/_service.ts
-var BotUpdatePollerService = class extends Context2.Tag("BotUpdatePollerService")() {
+var BotUpdatePollerService = class extends Context3.Tag("BotUpdatePollerService")() {
 };
 var BotUpdatesPollerServiceDefault = Micro4.gen(function* () {
   console.log("Initiating BotUpdatesPollerServiceDefault");
   const state = {
     fiber: void 0
   };
-  const runBot = (messageHandler) => Micro4.gen(function* () {
-    const startFiber = pollAndHandle({
+  const runBot = Micro4.gen(function* () {
+    console.log("run bot");
+    const messageHandler = yield* Micro4.service(BotMessageHandler);
+    const startFiber = pollUpdates({
       settings: messageHandler
     }).pipe(
       Micro4.forkDaemon,
       Micro4.tap(
         (fiber) => fiber.addObserver((exit) => {
           console.log("bot's fiber has been closed", exit);
-          if (messageHandler.onExit) {
-            messageHandler.onExit(exit);
-          }
         })
       )
     );
@@ -304,10 +385,10 @@ var BotUpdatesPollerServiceDefault = Micro4.gen(function* () {
     }
     state.fiber = yield* startFiber;
     console.log("Fetching bot updates via long polling...");
-    return state.fiber;
   });
   return {
-    runBot
+    runBot,
+    getFiber: () => state.fiber
   };
 });
 
@@ -333,66 +414,53 @@ var makeClientConfigFrom = (input) => Micro5.gen(function* () {
   return makeTgBotClientConfig(config);
 });
 
-// src/bot/factory/make-bot.ts
-import * as Micro6 from "effect/Micro";
-var makeBot = (messageHandler) => Micro6.gen(function* () {
-  const { runBot } = yield* Micro6.service(BotUpdatePollerService);
-  const fiber = yield* runBot(messageHandler);
-  const interrupt = Micro6.fiberInterrupt(fiber);
-  return {
-    runBot,
-    interrupt
-  };
-}).pipe(
-  Micro6.tapError((error) => {
-    console.error(error);
-    return Micro6.void;
-  })
-);
-
 // src/bot/factory/_service.ts
-var BotFactoryService = class extends Context3.Tag("BotFactoryService")() {
+var BotFactoryService = class extends Context4.Tag("BotFactoryService")() {
 };
 var BotFactoryServiceDefault = {
-  makeBot,
-  runBot: (input) => Micro7.gen(function* () {
-    const client = Context3.make(TgBotClientConfig, yield* makeClientConfigFrom(input));
+  runBot: (input) => Micro6.gen(function* () {
+    const client = Context4.make(TgBotClientConfig, yield* makeClientConfigFrom(input));
     const poller = yield* BotUpdatesPollerServiceDefault.pipe(
-      Micro7.provideContext(client)
+      Micro6.provideContext(client)
     );
-    const bot = yield* makeBot(input).pipe(
-      Micro7.provideContext(client),
-      Micro7.provideService(BotUpdatePollerService, poller)
+    yield* poller.runBot.pipe(
+      Micro6.provideService(BotMessageHandler, input),
+      Micro6.provideContext(client)
     );
-    const reload = (input2) => bot.runBot(input2).pipe(
-      Micro7.provideContext(client)
+    const reload = (input2) => poller.runBot.pipe(
+      Micro6.provideService(BotMessageHandler, input2),
+      Micro6.provideContext(client),
+      Micro6.runPromise
     );
     return {
       reload,
-      bot
+      fiber: poller.getFiber
     };
   })
 };
 
 // src/bot/run.ts
-import * as Micro8 from "effect/Micro";
-var runTgChatBot = (input) => BotFactoryServiceDefault.runBot(input).pipe(Micro8.runPromise);
+import * as Micro7 from "effect/Micro";
+var runTgChatBot = (input) => BotFactoryServiceDefault.runBot(input).pipe(
+  Micro7.provideService(BotMessageHandler, input),
+  Micro7.runPromise
+);
 
 // src/client/_client.ts
-import * as Micro11 from "effect/Micro";
+import * as Micro10 from "effect/Micro";
 
 // src/client/file/_service.ts
-import * as Micro10 from "effect/Micro";
-import * as Context4 from "effect/Context";
+import * as Micro9 from "effect/Micro";
+import * as Context5 from "effect/Context";
 
 // src/client/file/get-file.ts
-import * as Micro9 from "effect/Micro";
-var getFile = (fileId) => Micro9.gen(function* () {
+import * as Micro8 from "effect/Micro";
+var getFile = (fileId) => Micro8.gen(function* () {
   const response = yield* execute("get_file", { file_id: fileId });
-  const config = yield* Micro9.service(TgBotClientConfig);
+  const config = yield* Micro8.service(TgBotClientConfig);
   const file_path = response.file_path;
   if (!file_path || file_path.length == 0) {
-    return yield* Micro9.fail(
+    return yield* Micro8.fail(
       new TgBotClientError({
         reason: {
           type: "UnableToGetFile",
@@ -403,7 +471,7 @@ var getFile = (fileId) => Micro9.gen(function* () {
   }
   const file_name = file_path.replaceAll("/", "-");
   const url = `${config.base_url}/file/bot${config.bot_token}/${file_path}`;
-  const fileContent = yield* Micro9.tryPromise({
+  const fileContent = yield* Micro8.tryPromise({
     try: () => fetch(url).then((_) => _.arrayBuffer()),
     catch: (cause) => new TgBotClientError({
       reason: { type: "UnableToGetFile", cause }
@@ -414,9 +482,9 @@ var getFile = (fileId) => Micro9.gen(function* () {
 });
 
 // src/client/file/_service.ts
-var ClientFileService = class extends Context4.Tag("ClientFileService")() {
+var ClientFileService = class extends Context5.Tag("ClientFileService")() {
 };
-var ClientFileServiceDefault = Micro10.gen(function* () {
+var ClientFileServiceDefault = Micro9.gen(function* () {
   return {
     getFile: (input) => getFile(input.file_id)
   };
@@ -425,28 +493,29 @@ var ClientFileServiceDefault = Micro10.gen(function* () {
 // src/client/_client.ts
 var makeTgBotClient = (input) => {
   const config = makeTgBotClientConfig(input);
-  const client = Micro11.gen(function* () {
-    const file = yield* Micro11.service(ClientFileService);
+  const client = Micro10.gen(function* () {
+    const file = yield* Micro10.service(ClientFileService);
     return {
       execute: (method, input2) => execute(method, input2).pipe(
-        Micro11.provideService(TgBotClientConfig, config),
-        Micro11.runPromise
+        Micro10.provideService(TgBotClientConfig, config),
+        Micro10.runPromise
       ),
       getFile: (input2) => file.getFile(input2).pipe(
-        Micro11.provideService(TgBotClientConfig, config),
-        Micro11.runPromise
+        Micro10.provideService(TgBotClientConfig, config),
+        Micro10.runPromise
       )
     };
   }).pipe(
-    Micro11.provideServiceEffect(ClientFileService, ClientFileServiceDefault),
-    Micro11.provideService(TgBotClientConfig, config),
-    Micro11.runSync
+    Micro10.provideServiceEffect(ClientFileService, ClientFileServiceDefault),
+    Micro10.provideService(TgBotClientConfig, config),
+    Micro10.runSync
   );
   return client;
 };
 export {
   BotFactoryService,
   BotFactoryServiceDefault,
+  BotResponse,
   BotUpdatePollerService,
   BotUpdatesPollerServiceDefault,
   MESSAGE_EFFECTS,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect-ak/tg-bot-client",
-  "version": "0.3.2",
+  "version": "0.4.0",
   "homepage": "https://effect-ak.github.io/telegram-bot-client",
   "author": {
     "name": "Aleksandr Kondaurov",