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

package/dist/index.mjs

@@ -1,5 +1,84 @@
-// src/client/_client.ts
-import * as Micro5 from "effect/Micro";
+// src/bot/factory/_service.ts
+import * as Micro7 from "effect/Micro";
+import * as Context3 from "effect/Context";
+
+// src/bot/update-poller/_service.ts
+import * as Micro4 from "effect/Micro";
+import * as Context2 from "effect/Context";
+
+// src/bot/update-poller/poll-and-handle.ts
+import * as Micro3 from "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;
+  let update_types = input.update_types;
+  let log_level = input.log_level;
+  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 (!update_types) {
+    console.info("Handling only messages, ignoring others");
+    update_types = ["message"];
+  }
+  if (!log_level) {
+    log_level = "info";
+  }
+  return {
+    limit,
+    timeout,
+    max_empty_responses,
+    update_types,
+    log_level
+  };
+};
+
+// src/bot/update-poller/fetch-updates.ts
+import * as Micro2 from "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;
+};
+
+// src/client/execute-request/execute.ts
+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") {
+  static missingSuccess = new _TgBotClientError({
+    reason: {
+      type: "ClientInternalError",
+      cause: "Expected 'success' to be defined"
+    }
+  });
+};
 
 // src/client/config.ts
 import * as Context from "effect/Context";
@@ -27,25 +106,6 @@ var makeTgBotClientConfig = (input) => TgBotClientConfig.of({
 var TgBotClientConfig = class extends Context.Tag("TgBotClientConfig")() {
 };
 
-// src/client/execute-request/_service.ts
-import * as Micro2 from "effect/Micro";
-import * as Context2 from "effect/Context";
-
-// src/client/execute-request/execute.ts
-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") {
-  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");
@@ -70,7 +130,8 @@ var makePayload = (body) => {
 };
 
 // src/client/execute-request/execute.ts
-var execute = (config, method, input) => Micro.gen(function* () {
+var execute = (method, input) => Micro.gen(function* () {
+  const config = yield* Micro.service(TgBotClientConfig);
   const httpResponse = yield* Micro.tryPromise({
     try: () => fetch(
       `${config.base_url}/bot${config.bot_token}/${String.snakeToCamel(method)}`,
@@ -106,143 +167,17 @@ var execute = (config, method, input) => Micro.gen(function* () {
   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
-import * as Micro4 from "effect/Micro";
-import * as Context3 from "effect/Context";
-
-// src/client/file/get-file.ts
-import * as Micro3 from "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
-import * as Micro12 from "effect/Micro";
-
-// src/bot/factory/_service.ts
-import * as Micro11 from "effect/Micro";
-import * as Context5 from "effect/Context";
-
-// src/bot/update-poller/_service.ts
-import * as Micro8 from "effect/Micro";
-import * as Context4 from "effect/Context";
-
-// src/bot/update-poller/poll-and-handle.ts
-import * as Micro7 from "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
-import * as Micro6 from "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* () {
+var fetchUpdates = ({ state, settings, handlers }) => Micro2.gen(function* () {
   const updateId = state.lastUpdateId;
-  console.info("getting updates", state);
-  const updates = yield* execute2("get_updates", {
+  if (settings.log_level == "debug") {
+    console.debug("getting updates", state);
+  }
+  const updates = yield* execute("get_updates", {
     ...settings,
     ...updateId ? { offset: updateId } : void 0
   }).pipe(
-    Micro6.andThen((_) => _.sort((_2) => _2.update_id))
+    Micro2.andThen((_) => _.sort((_2) => _2.update_id))
   );
   let lastSuccessId = void 0;
   let hasError = false;
@@ -255,34 +190,49 @@ var fetchUpdates = ({ state, settings, execute: execute2, handlers }) => Micro6.
     }
     const handler = handlers[`on_${update.type}`];
     if (!handler) {
-      console.warn("Handler for update not defined", update);
-      hasError = true;
-      break;
+      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) {
-      const response = yield* execute2(`send_${handleResult.type}`, {
+    if ("chat" in update && handleResult) {
+      const response = yield* execute(`send_${handleResult.type}`, {
         ...handleResult,
         chat_id: update.chat.id
       });
-      console.log("bot response", response);
+      if (settings.log_level == "debug" && "text") {
+        console.debug("bot response", response);
+      }
     }
-    if (!handleResult) {
-      hasError = true;
-      console.log(handleResult);
-      break;
+    if (!handleResult && settings.log_level == "debug") {
+      console.debug("handler returned no response for update", { update });
     }
     ;
     lastSuccessId = updateObject.update_id;
   }
   if (hasError && lastSuccessId) {
-    const resp = (
-      //commit successfully handled messages
-      yield* execute2("get_updates", {
-        offset: lastSuccessId,
-        limit: 0
-      })
-    );
+    yield* execute("get_updates", {
+      offset: lastSuccessId,
+      limit: 0
+    });
+    if (settings.log_level == "debug") {
+      console.debug("committed offset", lastSuccessId);
+    }
   }
   return { updates, lastSuccessId, hasError };
 });
@@ -294,18 +244,17 @@ var pollAndHandle = (input) => {
     emptyResponses: 0
   };
   const settings = makeSettingsFrom(input.settings);
-  return Micro7.delay(1e3)(
+  return Micro3.delay(1e3)(
     fetchUpdates({
       state,
       settings,
-      execute: input.execute,
       handlers: input.settings
     })
   ).pipe(
-    Micro7.repeat({
+    Micro3.repeat({
       while: ({ updates, lastSuccessId, hasError }) => {
         if (hasError) {
-          console.warn("error in handler, quitting");
+          console.info("error in handler, quitting");
           return false;
         }
         if (updates.length == 0) {
@@ -328,22 +277,19 @@ var pollAndHandle = (input) => {
 };
 
 // src/bot/update-poller/_service.ts
-var BotUpdatePollerService = class extends Context4.Tag("BotUpdatePollerService")() {
+var BotUpdatePollerService = class extends Context2.Tag("BotUpdatePollerService")() {
 };
-var BotUpdatesPollerServiceDefault = Micro8.gen(function* () {
+var BotUpdatesPollerServiceDefault = Micro4.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 runBot = (messageHandler) => Micro4.gen(function* () {
     const startFiber = pollAndHandle({
-      settings: messageHandler,
-      execute: client.execute
+      settings: messageHandler
     }).pipe(
-      Micro8.forkDaemon,
-      Micro8.tap(
+      Micro4.forkDaemon,
+      Micro4.tap(
         (fiber) => fiber.addObserver((exit) => {
           console.log("bot's fiber has been closed", exit);
           if (messageHandler.onExit) {
@@ -354,82 +300,155 @@ var BotUpdatesPollerServiceDefault = Micro8.gen(function* () {
     );
     if (state.fiber) {
       console.log("killing previous bot's fiber");
-      yield* Micro8.fiberInterrupt(state.fiber);
+      yield* Micro4.fiberInterrupt(state.fiber);
     }
     state.fiber = yield* startFiber;
-    console.log("Reading bot's updates.....", state.fiber == null);
+    console.log("Fetching bot updates via long polling...");
     return state.fiber;
   });
   return {
     runBot
   };
-}).pipe(
-  Micro8.provideServiceEffect(ClientExecuteRequestService, ClientExecuteRequestServiceDefault)
-);
+});
 
 // src/bot/factory/client-config.ts
-import * as Micro9 from "effect/Micro";
-var makeClientConfigFrom = (input) => Micro9.gen(function* () {
+import * as Micro5 from "effect/Micro";
+var makeClientConfigFrom = (input) => Micro5.gen(function* () {
   if (input.type == "config") {
     return makeTgBotClientConfig(input);
   }
-  const config = yield* Micro9.tryPromise({
+  const config = yield* Micro5.tryPromise({
     try: async () => {
       const { readFileSync } = await import("fs");
       return JSON.parse(await readFileSync("config.json", "utf-8"));
     },
     catch: (error) => {
-      console.warn(error);
+      console.warn("invalid tg bot config", error);
       return "ReadingConfigError";
     }
   });
   if (!isTgBotClientSettingsInput(config)) {
-    return yield* Micro9.fail("InvalidConfig");
+    return yield* Micro5.fail("InvalidConfig");
   }
   return makeTgBotClientConfig(config);
 });
 
 // src/bot/factory/make-bot.ts
-import * as Micro10 from "effect/Micro";
-var makeBot = (messageHandler) => Micro10.gen(function* () {
-  const { runBot } = yield* Micro10.service(BotUpdatePollerService);
+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 {
-    fiber: yield* runBot(messageHandler),
-    runBot
+    runBot,
+    interrupt
   };
 }).pipe(
-  Micro10.tapError((error) => {
+  Micro6.tapError((error) => {
     console.error(error);
-    return Micro10.void;
+    return Micro6.void;
   })
 );
 
 // src/bot/factory/_service.ts
-var BotFactoryService = class extends Context5.Tag("BotFactoryService")() {
+var BotFactoryService = class extends Context3.Tag("BotFactoryService")() {
 };
 var BotFactoryServiceDefault = {
   makeBot,
-  runBot: (input) => Micro11.gen(function* () {
-    console.log("client");
-    const client = yield* makeClientConfigFrom(input);
+  runBot: (input) => Micro7.gen(function* () {
+    const client = Context3.make(TgBotClientConfig, yield* makeClientConfigFrom(input));
     const poller = yield* BotUpdatesPollerServiceDefault.pipe(
-      Micro11.provideService(TgBotClientConfig, client)
+      Micro7.provideContext(client)
     );
     const bot = yield* makeBot(input).pipe(
-      Micro11.provideService(BotUpdatePollerService, poller)
+      Micro7.provideContext(client),
+      Micro7.provideService(BotUpdatePollerService, poller)
+    );
+    const reload = (input2) => bot.runBot(input2).pipe(
+      Micro7.provideContext(client)
     );
-    const reload = (input2) => bot.runBot(input2).pipe(Micro11.runPromise);
     return {
-      reload
+      reload,
+      bot
     };
   })
 };
 
 // src/bot/run.ts
-var runTgChatBot = (input) => BotFactoryServiceDefault.runBot(input).pipe(Micro12.runPromise);
+import * as Micro8 from "effect/Micro";
+var runTgChatBot = (input) => BotFactoryServiceDefault.runBot(input).pipe(Micro8.runPromise);
+
+// src/client/_client.ts
+import * as Micro11 from "effect/Micro";
+
+// src/client/file/_service.ts
+import * as Micro10 from "effect/Micro";
+import * as Context4 from "effect/Context";
+
+// src/client/file/get-file.ts
+import * as Micro9 from "effect/Micro";
+var getFile = (fileId) => Micro9.gen(function* () {
+  const response = yield* execute("get_file", { file_id: fileId });
+  const config = yield* Micro9.service(TgBotClientConfig);
+  const file_path = response.file_path;
+  if (!file_path || file_path.length == 0) {
+    return yield* Micro9.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* Micro9.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 Context4.Tag("ClientFileService")() {
+};
+var ClientFileServiceDefault = Micro10.gen(function* () {
+  return {
+    getFile: (input) => getFile(input.file_id)
+  };
+});
+
+// src/client/_client.ts
+var makeTgBotClient = (input) => {
+  const config = makeTgBotClientConfig(input);
+  const client = Micro11.gen(function* () {
+    const file = yield* Micro11.service(ClientFileService);
+    return {
+      execute: (method, input2) => execute(method, input2).pipe(
+        Micro11.provideService(TgBotClientConfig, config),
+        Micro11.runPromise
+      ),
+      getFile: (input2) => file.getFile(input2).pipe(
+        Micro11.provideService(TgBotClientConfig, config),
+        Micro11.runPromise
+      )
+    };
+  }).pipe(
+    Micro11.provideServiceEffect(ClientFileService, ClientFileServiceDefault),
+    Micro11.provideService(TgBotClientConfig, config),
+    Micro11.runSync
+  );
+  return client;
+};
 export {
   BotFactoryService,
   BotFactoryServiceDefault,
+  BotUpdatePollerService,
+  BotUpdatesPollerServiceDefault,
   MESSAGE_EFFECTS,
   defaultBaseUrl,
   isMessageEffect,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect-ak/tg-bot-client",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "homepage": "https://effect-ak.github.io/telegram-bot-client",
   "author": {
     "name": "Aleksandr Kondaurov",
@@ -47,9 +47,5 @@
   },
   "dependencies": {
     "effect": "^3.11.0"
-  },
-  "scripts": {
-    "gen": "tsx ./codegen/main",
-    "echo-bot": "tsx ./example/echo-bot.ts"
   }
 }