@effect-ak/tg-bot-client 0.4.1 → 0.5.0

package/dist/index.mjs

@@ -1,73 +1,54 @@
-// src/bot/factory/_service.ts
+// src/bot/internal/launch.ts
 import * as Micro6 from "effect/Micro";
-import * as Context4 from "effect/Context";
+import * as Context6 from "effect/Context";
 
-// src/bot/message-handler/_service.ts
+// src/client/config.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 Context3 from "effect/Context";
 
-// src/bot/update-poller/poll-updates.ts
-import * as Micro3 from "effect/Micro";
+// 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/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;
-  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;
-  }
-  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;
-  }
-  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;
-  }
-  if (!log_level) {
-    log_level = "info";
-  }
-  if (!on_error) {
-    on_error = "stop";
-  }
-  const config = {
-    limit,
-    timeout,
-    max_empty_responses,
-    log_level,
-    on_error
-  };
-  console.log("bot configuration", config);
-  return config;
+// src/client/config.ts
+var makeTgBotClientConfig = (input) => TgBotClientConfig.of({
+  ...input,
+  base_url: input.base_url ?? defaultBaseUrl
+});
+var TgBotClientConfig = class extends Context.Tag("TgBotClientConfig")() {
 };
 
-// src/bot/update-poller/fetch-and-handle.ts
-import * as Micro2 from "effect/Micro";
+// src/bot/internal/types.ts
 import * as Data from "effect/Data";
-
-// src/bot/message-handler/types.ts
-import { TaggedClass } from "effect/Data";
-var BotResponse = class _BotResponse extends TaggedClass("BotResponse") {
+import * as Context2 from "effect/Context";
+var BotResponse = class _BotResponse extends Data.TaggedClass("BotResponse") {
   static make(result) {
     return new _BotResponse({ response: result });
   }
   static ignore = new _BotResponse({});
 };
+var BotUpdateHandlersTag = class extends Context2.Tag("BotUpdateHandlers")() {
+};
+
+// src/bot/service/run.ts
+import * as Micro4 from "effect/Micro";
+import * as Context5 from "effect/Context";
 
-// src/bot/message-handler/utils.ts
+// src/bot/internal/handle-update.ts
+import * as Micro2 from "effect/Micro";
+import * as Data3 from "effect/Data";
+
+// src/bot/internal/utils.ts
 var extractUpdate = (input) => {
   for (const [field, value] of Object.entries(input)) {
     if (field == "update_id") {
@@ -96,32 +77,6 @@ var TgBotClientError = class _TgBotClientError extends TaggedError("TgBotClientE
   });
 };
 
-// src/client/config.ts
-import * as Context2 from "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 Context2.Tag("TgBotClientConfig")() {
-};
-
 // 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");
@@ -183,55 +138,129 @@ var execute = (method, input) => Micro.gen(function* () {
   return response.result;
 });
 
-// src/bot/update-poller/fetch-and-handle.ts
-var HandleUpdateError = class extends Data.TaggedError("HandleUpdateError") {
+// src/bot/internal/poll-settings.ts
+import * as Context3 from "effect/Context";
+import * as Data2 from "effect/Data";
+var BotPollSettings = class _BotPollSettings extends Data2.Class {
+  static make(input) {
+    let batch_size = input.batch_size ?? 10;
+    let poll_timeout = input.poll_timeout ?? 10;
+    let max_empty_responses = input.max_empty_responses;
+    let log_level = input.log_level ?? "info";
+    let on_error = input.on_error;
+    if (batch_size < 10 || batch_size > 100) {
+      console.warn("Wrong batch_size, must be in [10..100], using 10 instead");
+      batch_size = 10;
+    }
+    if (poll_timeout < 2 || poll_timeout > 10) {
+      console.warn("Wrong poll_timeout, must be in [2..10], using 2 instead");
+      poll_timeout = 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;
+    }
+    if (!log_level) {
+      log_level = "info";
+    }
+    if (!on_error) {
+      on_error = "stop";
+    }
+    const config = new _BotPollSettings({
+      batch_size,
+      poll_timeout,
+      max_empty_responses,
+      log_level,
+      on_error
+    });
+    console.log("bot poll settings", config);
+    return config;
+  }
 };
-var fetchAndHandle = ({ state, settings, handlers }) => Micro2.gen(function* () {
-  const updateId = state.lastUpdateId;
-  if (settings.log_level == "debug") {
-    console.debug("getting updates", state);
+var BotPollSettingsTag = class extends Context3.Reference()(
+  "BotSettings",
+  {
+    defaultValue() {
+      return BotPollSettings.make({});
+    }
   }
-  const updates = yield* execute("get_updates", {
-    ...settings,
-    ...updateId ? { offset: updateId } : void 0
-  }).pipe(
-    Micro2.andThen((_) => _.sort((_2) => _2.update_id))
-  );
-  if (updates.length) {
-    console.debug(`got a batch of updates (${updates.length})`);
+) {
+};
+
+// src/bot/internal/handle-update.ts
+var BatchUpdateResult = class extends Data3.Class {
+};
+var handleUpdates = (updates) => Micro2.gen(function* () {
+  const pollSettings = yield* Micro2.service(BotPollSettingsTag);
+  const updateHandler = yield* Micro2.service(BotUpdateHandlersTag);
+  if (updateHandler.type == "single") {
+    return yield* handleOneByOne(updates, updateHandler, pollSettings);
+  } else {
+    return yield* handleEntireBatch(updates, updateHandler, pollSettings);
   }
-  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(void 0);
-      })
-    ),
-    {
-      concurrency: 10
+});
+var handleEntireBatch = (updates, handlers, pollSettings) => Micro2.try({
+  try: () => handlers.on_batch(updates),
+  catch: (_) => _
+}).pipe(
+  Micro2.andThen((result) => {
+    if (result instanceof Promise) {
+      return Micro2.tryPromise({
+        try: () => result,
+        catch: (_) => _
+      });
+    } else {
+      return Micro2.succeed(result);
     }
-  ).pipe(
-    Micro2.andThen((result) => result.every((error) => error == null))
-  );
-  if (lastUpdateId) {
-    yield* execute("get_updates", {
-      offset: lastUpdateId,
-      limit: 0
+  }),
+  Micro2.andThen(
+    (doNext) => new BatchUpdateResult({
+      hasErrors: !doNext,
+      updates
+    })
+  ),
+  Micro2.catchAll((error) => {
+    console.log("handle batch error", {
+      errorMessage: error instanceof Error ? error.message : void 0,
+      updates: updates.map((_) => Object.keys(_).at(1))
     });
-    if (settings.log_level == "debug") {
-      console.debug("committed offset", lastUpdateId);
-    }
+    return Micro2.succeed(
+      new BatchUpdateResult({
+        hasErrors: true,
+        updates
+      })
+    );
+  })
+);
+var HandleUpdateError = class extends Data3.TaggedError("HandleUpdateError") {
+};
+var handleOneByOne = (updates, handlers, pollSettings) => Micro2.forEach(
+  updates,
+  (update) => handleOneUpdate(update, handlers).pipe(
+    Micro2.catchAll((error) => {
+      console.log("update handle error", {
+        updateId: update.update_id,
+        updateKey: Object.keys(update).at(1),
+        name: error._tag
+      });
+      return Micro2.succeed(error);
+    })
+  ),
+  {
+    concurrency: 10
   }
-  return { updates, lastUpdateId, hasError };
-});
-var handleUpdate = (updateObject, settings, handlers) => Micro2.gen(function* () {
+).pipe(
+  Micro2.andThen((batchResult) => {
+    if (pollSettings.log_level == "debug") {
+      console.debug("handle batch result", batchResult);
+    }
+    return new BatchUpdateResult({
+      hasErrors: !batchResult.every((error) => error == null),
+      updates
+    });
+  })
+);
+var handleOneUpdate = (updateObject, handlers) => Micro2.gen(function* () {
   const update = extractUpdate(updateObject);
   if (!update) {
     return yield* Micro2.fail(
@@ -241,8 +270,8 @@ var handleUpdate = (updateObject, settings, handlers) => Micro2.gen(function* ()
       })
     );
   }
-  const handler = handlers[`on_${update.type}`];
-  if (!handler) {
+  const updateHandler = handlers[`on_${update.type}`];
+  if (!updateHandler) {
     return yield* Micro2.fail(
       new HandleUpdateError({
         name: "HandlerNotDefined",
@@ -259,7 +288,7 @@ var handleUpdate = (updateObject, settings, handlers) => Micro2.gen(function* ()
   }
   let handleUpdateError;
   const handleResult = yield* Micro2.try({
-    try: () => handler(update),
+    try: () => updateHandler(update),
     catch: (error) => new HandleUpdateError({
       name: "BotHandlerError",
       update: updateObject,
@@ -281,6 +310,11 @@ var handleUpdate = (updateObject, settings, handlers) => Micro2.gen(function* ()
     }),
     Micro2.catchAll((error) => {
       handleUpdateError = error;
+      console.log("error", {
+        updateId: updateObject.update_id,
+        updateKey: Object.keys(update).at(1),
+        name: error._tag
+      });
       return Micro2.succeed(
         BotResponse.make({
           type: "message",
@@ -295,7 +329,8 @@ var handleUpdate = (updateObject, settings, handlers) => Micro2.gen(function* ()
       );
     })
   );
-  if (!handleResult && settings.log_level == "debug") {
+  const pollSettings = yield* Micro2.service(BotPollSettingsTag);
+  if (!handleResult && pollSettings.log_level == "debug") {
     console.log(`Bot response is undefined for update with ID #${updateObject.update_id}.`);
     return;
   }
@@ -305,87 +340,144 @@ var handleUpdate = (updateObject, settings, handlers) => Micro2.gen(function* ()
       ...handleResult.response,
       chat_id: update.chat.id
     });
-    if (settings.log_level == "debug" && "text") {
+    if (pollSettings.log_level == "debug" && "text") {
       console.debug("bot response", response);
     }
   }
   return handleUpdateError;
 });
 
-// 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)(
-    fetchAndHandle({
-      state,
-      settings,
-      handlers: input.settings
-    })
-  ).pipe(
-    Micro3.repeat({
-      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) {
-          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 (lastUpdateId) {
-          state.lastUpdateId = lastUpdateId + 1;
-        }
-        return true;
-      }
-    })
-  );
+// src/bot/service/fetch-updates.ts
+import * as Micro3 from "effect/Micro";
+import * as Data4 from "effect/Data";
+import * as Context4 from "effect/Context";
+var BotFetchUpdatesService = class extends Context4.Reference()(
+  "BotFetchUpdatesService",
+  {
+    defaultValue: () => {
+      const state = {
+        lastUpdateId: void 0,
+        emptyResponses: 0
+      };
+      const fetchUpdates = _fetchUpdates(state).pipe(
+        Micro3.tap((updates) => {
+          const id = updates.map((_) => _.update_id).sort().at(-1);
+          console.log("updating last update id", id);
+          state.lastUpdateId = id ? id + 1 : void 0;
+          console.log(state);
+        })
+      );
+      const commit = _commitLastBatch(state);
+      return {
+        state,
+        fetchUpdates,
+        commit
+      };
+    }
+  }
+) {
 };
-
-// src/bot/update-poller/_service.ts
-var BotUpdatePollerService = class extends Context3.Tag("BotUpdatePollerService")() {
+var FetchUpdatesError = class extends Data4.TaggedError("FetchUpdatesError") {
 };
-var BotUpdatesPollerServiceDefault = Micro4.gen(function* () {
-  console.log("Initiating BotUpdatesPollerServiceDefault");
-  const state = {
-    fiber: void 0
-  };
-  const runBot = Micro4.gen(function* () {
-    console.log("run bot");
-    const messageHandler = yield* Micro4.service(BotMessageHandler);
-    const startFiber = pollUpdates({
-      settings: messageHandler
+var _fetchUpdates = (pollState) => Micro3.gen(function* () {
+  const pollSettings = yield* Micro3.service(BotPollSettingsTag);
+  if (pollSettings.max_empty_responses && pollState.emptyResponses == pollSettings.max_empty_responses) {
+    return yield* Micro3.fail(
+      new FetchUpdatesError({ name: "TooManyEmptyResponses" })
+    );
+  }
+  const updateId = pollState.lastUpdateId;
+  if (pollSettings.log_level == "debug") {
+    console.debug("getting updates", pollState);
+  }
+  const updates = yield* execute("get_updates", {
+    timeout: pollSettings.poll_timeout,
+    ...updateId ? { offset: updateId } : void 0
+  }).pipe(
+    Micro3.andThen((_) => _.sort((_2) => _2.update_id))
+  );
+  if (updates.length) {
+    console.debug(`got a batch of updates (${updates.length})`);
+    pollState.emptyResponses = 0;
+    return updates;
+  } else {
+    pollState.emptyResponses += 1;
+    return [];
+  }
+});
+var _commitLastBatch = (pollState) => Micro3.gen(function* () {
+  console.log("commit", { pollState });
+  if (pollState.lastUpdateId) {
+    return yield* execute("get_updates", {
+      offset: pollState.lastUpdateId,
+      limit: 0
     }).pipe(
-      Micro4.forkDaemon,
-      Micro4.tap(
-        (fiber) => fiber.addObserver((exit) => {
-          console.log("bot's fiber has been closed", exit);
+      Micro3.andThen(
+        Micro3.andThen(Micro3.service(BotPollSettingsTag), (pollSettings) => {
+          if (pollSettings.log_level == "debug") {
+            console.debug("committed offset", pollState);
+          }
         })
       )
     );
-    if (state.fiber) {
-      console.log("killing previous bot's fiber");
-      yield* Micro4.fiberInterrupt(state.fiber);
+  } else {
+    return yield* Micro3.fail(new FetchUpdatesError({
+      name: "NoUpdatesToCommit"
+    }));
+  }
+});
+
+// src/bot/service/run.ts
+var BotRunService = class extends Context5.Reference()(
+  "BotRunService",
+  {
+    defaultValue: () => {
+      console.log("Initiating BotRunService");
+      const state = {
+        fiber: void 0
+      };
+      const runBotInBackground = _runBotDaemon(state);
+      const getFiber = () => state.fiber;
+      return {
+        runBotInBackground,
+        getFiber
+      };
     }
-    state.fiber = yield* startFiber;
-    console.log("Fetching bot updates via long polling...");
-  });
-  return {
-    runBot,
-    getFiber: () => state.fiber
-  };
+  }
+) {
+};
+var _runBotDaemon = (state) => Micro4.gen(function* () {
+  console.log("run bot");
+  const fetchService = yield* Micro4.service(BotFetchUpdatesService);
+  const startFiber = Micro4.delay(1e3)(
+    fetchService.fetchUpdates.pipe(
+      Micro4.andThen(
+        (updates) => handleUpdates(updates)
+      ),
+      Micro4.tap(
+        ({ updates }) => updates.length > 0 ? fetchService.commit : Micro4.void
+      )
+    )
+  ).pipe(
+    Micro4.repeat({
+      while: (_) => !_.hasErrors
+    }),
+    Micro4.forkDaemon,
+    Micro4.tap(
+      (fiber) => fiber.addObserver((exit) => {
+        console.log("bot's fiber has been closed", exit);
+      })
+    )
+  );
+  if (state.fiber) {
+    console.log("killing previous bot's fiber");
+    yield* Micro4.fiberInterrupt(state.fiber);
+  }
+  state.fiber = yield* startFiber;
+  console.log("Fetching bot updates via long polling...");
 });
 
-// src/bot/factory/client-config.ts
+// src/bot/internal/client-config.ts
 import * as Micro5 from "effect/Micro";
 var makeClientConfigFrom = (input) => Micro5.gen(function* () {
   if (input.type == "config") {
@@ -407,35 +499,29 @@ var makeClientConfigFrom = (input) => Micro5.gen(function* () {
   return makeTgBotClientConfig(config);
 });
 
-// src/bot/factory/_service.ts
-var BotFactoryService = class extends Context4.Tag("BotFactoryService")() {
-};
-var BotFactoryServiceDefault = {
-  runBot: (input) => Micro6.gen(function* () {
-    const client = Context4.make(TgBotClientConfig, yield* makeClientConfigFrom(input));
-    const poller = yield* BotUpdatesPollerServiceDefault.pipe(
-      Micro6.provideContext(client)
-    );
-    yield* poller.runBot.pipe(
-      Micro6.provideService(BotMessageHandler, input),
-      Micro6.provideContext(client)
-    );
-    const reload = (input2) => poller.runBot.pipe(
-      Micro6.provideService(BotMessageHandler, input2),
-      Micro6.provideContext(client),
-      Micro6.runPromise
-    );
-    return {
-      reload,
-      fiber: poller.getFiber
-    };
-  })
-};
+// src/bot/internal/launch.ts
+var launchBot = (input) => Micro6.gen(function* () {
+  const clientConfig = Context6.make(TgBotClientConfig, yield* makeClientConfigFrom(input));
+  const service8 = yield* Micro6.service(BotRunService);
+  yield* service8.runBotInBackground.pipe(
+    Micro6.provideContext(clientConfig),
+    Micro6.provideService(BotUpdateHandlersTag, input.mode),
+    Micro6.provideService(BotPollSettingsTag, BotPollSettings.make(input.poll ?? {}))
+  );
+  const reload = (mode) => service8.runBotInBackground.pipe(
+    Micro6.provideService(BotUpdateHandlersTag, mode),
+    Micro6.provideContext(clientConfig),
+    Micro6.runPromise
+  );
+  return {
+    reload,
+    fiber: service8.getFiber
+  };
+});
 
 // src/bot/run.ts
 import * as Micro7 from "effect/Micro";
-var runTgChatBot = (input) => BotFactoryServiceDefault.runBot(input).pipe(
-  Micro7.provideService(BotMessageHandler, input),
+var runTgChatBot = (input) => launchBot(input).pipe(
   Micro7.runPromise
 );
 
@@ -444,7 +530,7 @@ import * as Micro10 from "effect/Micro";
 
 // src/client/file/_service.ts
 import * as Micro9 from "effect/Micro";
-import * as Context5 from "effect/Context";
+import * as Context7 from "effect/Context";
 
 // src/client/file/get-file.ts
 import * as Micro8 from "effect/Micro";
@@ -475,7 +561,7 @@ var getFile = (fileId) => Micro8.gen(function* () {
 });
 
 // src/client/file/_service.ts
-var ClientFileService = class extends Context5.Tag("ClientFileService")() {
+var ClientFileService = class extends Context7.Tag("ClientFileService")() {
 };
 var ClientFileServiceDefault = Micro9.gen(function* () {
   return {
@@ -506,14 +592,13 @@ var makeTgBotClient = (input) => {
   return client;
 };
 export {
-  BotFactoryService,
-  BotFactoryServiceDefault,
   BotResponse,
-  BotUpdatePollerService,
-  BotUpdatesPollerServiceDefault,
+  BotRunService,
+  BotUpdateHandlersTag,
   MESSAGE_EFFECTS,
   defaultBaseUrl,
   isMessageEffect,
+  launchBot,
   makeTgBotClient,
   messageEffectIdCodes,
   runTgChatBot

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@effect-ak/tg-bot-client",
-  "version": "0.4.1",
-  "homepage": "https://effect-ak.github.io/telegram-bot-client",
+  "version": "0.5.0",
+  "homepage": "https://effect-ak.github.io/telegram-bot-playground/",
   "author": {
     "name": "Aleksandr Kondaurov",
     "email": "kondaurov.dev@gmail.com"