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

package/dist/dts/bot/factory/_service.d.ts

@@ -0,0 +1,37 @@
+import * as Micro from "effect/Micro";
+import * as Context from "effect/Context";
+import type { TgBotClientSettingsInput } from "../../client/guards.js";
+import type { BotMessageHandlerSettings } from "../../bot/message-handler/types.js";
+import { TgBotClientConfig } from "../../client/config.js";
+declare const BotFactoryService_base: Context.TagClass<BotFactoryService, "BotFactoryService", {
+    makeBot: (messageHandler: BotMessageHandlerSettings) => Micro.Micro<Micro.MicroFiber<{
+        updates: import("../../index.js").Update[];
+        lastSuccessId: number | undefined;
+        hasError: boolean;
+    }, import("../../client/errors.js").TgBotClientError>, string, TgBotClientConfig>;
+    runBot: (input: RunBotInput) => Micro.Micro<Micro.MicroFiber<{
+        updates: import("../../index.js").Update[];
+        lastSuccessId: number | undefined;
+        hasError: boolean;
+    }, import("../../client/errors.js").TgBotClientError>, string, never>;
+}>;
+export declare class BotFactoryService extends BotFactoryService_base {
+}
+export type RunBotInput = ({
+    type: "fromJsonFile";
+} | {
+    type: "config";
+} & TgBotClientSettingsInput) & BotMessageHandlerSettings;
+export declare const BotFactoryServiceDefault: {
+    makeBot: (messageHandler: BotMessageHandlerSettings) => Micro.Micro<Micro.MicroFiber<{
+        updates: import("../../index.js").Update[];
+        lastSuccessId: number | undefined;
+        hasError: boolean;
+    }, import("../../client/errors.js").TgBotClientError>, string, TgBotClientConfig>;
+    runBot: (input: RunBotInput) => Micro.Micro<Micro.MicroFiber<{
+        updates: import("../../index.js").Update[];
+        lastSuccessId: number | undefined;
+        hasError: boolean;
+    }, import("../../client/errors.js").TgBotClientError>, string, never>;
+};
+export {};

package/dist/dts/bot/factory/client-config.d.ts

@@ -0,0 +1,3 @@
+import * as Micro from "effect/Micro";
+import type { RunBotInput } from "./_service.js";
+export declare const makeClientConfigFrom: (input: RunBotInput) => Micro.Micro<Required<import("../../client/guards.js").TgBotClientSettingsInput>, string, never>;

package/dist/dts/bot/factory/make-bot.d.ts

@@ -0,0 +1,7 @@
+import * as Micro from "effect/Micro";
+import type { BotMessageHandlerSettings } from "../../bot/message-handler/types.js";
+export declare const makeBot: (messageHandler: BotMessageHandlerSettings) => Micro.Micro<Micro.MicroFiber<{
+    updates: import("../../index.js").Update[];
+    lastSuccessId: number | undefined;
+    hasError: boolean;
+}, import("../../client/errors.js").TgBotClientError>, string, import("../../client/config.js").TgBotClientConfig>;

package/dist/dts/bot/message-handler/_service.d.ts

@@ -0,0 +1,6 @@
+import * as Context from "effect/Context";
+import { BotMessageHandlerSettings } from "./types.js";
+declare const BotMessageHandler_base: Context.TagClass<BotMessageHandler, "BotMessageHandler", BotMessageHandlerSettings>;
+export declare class BotMessageHandler extends BotMessageHandler_base {
+}
+export {};

package/dist/dts/bot/message-handler/types.d.ts

@@ -0,0 +1,16 @@
+import type { Api } from "../../specification/api.js";
+import type { Update } from "../../specification/types.js";
+export type AvailableUpdateTypes = Exclude<keyof Update, 'update_id'>;
+export type BotResponse = {
+    [K in keyof Api]: K extends `send_${infer R}` ? {
+        type: Lowercase<R>;
+    } & Omit<Parameters<Api[K]>[0], 'chat_id'> : never;
+}[keyof Api];
+export type BotMessageHandlers = {
+    [K in AvailableUpdateTypes as `on_${K}`]?: (update: NonNullable<Update[K]>) => BotResponse;
+};
+export type BotMessageHandlerSettings = {
+    readonly batch_size?: number;
+    readonly timeout?: number;
+    readonly max_empty_responses?: number;
+} & BotMessageHandlers;

package/dist/dts/bot/message-handler/utils.d.ts

@@ -0,0 +1,6 @@
+import type { Update } from "../../specification/types.js";
+import { AvailableUpdateTypes } from "./types.js";
+export type ExtractedUpdate<K extends AvailableUpdateTypes> = {
+    type: K;
+} & Update[K];
+export declare const extractUpdate: <U extends AvailableUpdateTypes>(input: Update) => ExtractedUpdate<U> | undefined;

package/dist/dts/bot/run.d.ts

@@ -0,0 +1,7 @@
+import { Micro } from "effect";
+import { BotFactoryServiceDefault } from "./factory/_service.js";
+export declare const runTgChatBot: (input: Parameters<typeof BotFactoryServiceDefault.runBot>[0]) => Promise<Micro.MicroFiber<{
+    updates: import("../index.js").Update[];
+    lastSuccessId: number | undefined;
+    hasError: boolean;
+}, import("../client/errors.js").TgBotClientError>>;

package/dist/dts/bot/update-poller/_service.d.ts

@@ -0,0 +1,21 @@
+import * as Micro from "effect/Micro";
+import * as Context from "effect/Context";
+import { BotMessageHandlerSettings } from "../../bot/message-handler/types.js";
+export type BotUpdatePollerServiceInterface = Micro.Micro.Success<typeof BotUpdatesPollerServiceDefault>;
+declare const BotUpdatePollerService_base: Context.TagClass<BotUpdatePollerService, "BotUpdatePollerService", {
+    readonly runBot: (messageHandler: BotMessageHandlerSettings) => Micro.Micro<Micro.MicroFiber<{
+        updates: import("../../index.js").Update[];
+        lastSuccessId: number | undefined;
+        hasError: boolean;
+    }, import("../../client/errors.js").TgBotClientError>, string, never>;
+}>;
+export declare class BotUpdatePollerService extends BotUpdatePollerService_base {
+}
+export declare const BotUpdatesPollerServiceDefault: Micro.Micro<{
+    readonly runBot: (messageHandler: BotMessageHandlerSettings) => Micro.Micro<Micro.MicroFiber<{
+        updates: import("../../index.js").Update[];
+        lastSuccessId: number | undefined;
+        hasError: boolean;
+    }, import("../../client/errors.js").TgBotClientError>, string, never>;
+}, never, import("../../client/config.js").TgBotClientConfig>;
+export {};

package/dist/dts/bot/update-poller/errors.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/dts/bot/update-poller/fetch-updates.d.ts

@@ -0,0 +1,17 @@
+import * as Micro from "effect/Micro";
+import type { State } from "./poll-and-handle.js";
+import type { SafeSettings } from "./settings.js";
+import type { BotMessageHandlers } from "../message-handler/types.js";
+import type { ClientExecuteRequestServiceInterface } from "../../client/execute-request/_service.js";
+type Context = {
+    state: State;
+    settings: SafeSettings;
+    handlers: BotMessageHandlers;
+    execute: ClientExecuteRequestServiceInterface["execute"];
+};
+export declare const fetchUpdates: ({ state, settings, execute, handlers }: Context) => Micro.Micro<{
+    updates: import("../../index.js").Update[];
+    lastSuccessId: number | undefined;
+    hasError: boolean;
+}, import("../../client/errors.js").TgBotClientError, never>;
+export {};

package/dist/dts/bot/update-poller/poll-and-handle.d.ts

@@ -0,0 +1,16 @@
+import * as Micro from "effect/Micro";
+import type { ClientExecuteRequestServiceInterface } from "../../client/execute-request/_service.js";
+import type { BotMessageHandlerSettings } from "../../bot/message-handler/types.js";
+export type State = {
+    lastUpdateId: number | undefined;
+    emptyResponses: number;
+};
+export type PollAndHandleInput = {
+    settings: BotMessageHandlerSettings;
+    execute: ClientExecuteRequestServiceInterface["execute"];
+};
+export declare const pollAndHandle: (input: PollAndHandleInput) => Micro.Micro<{
+    updates: import("../../index.js").Update[];
+    lastSuccessId: number | undefined;
+    hasError: boolean;
+}, import("../../client/errors.js").TgBotClientError, never>;

package/dist/dts/bot/update-poller/settings.d.ts

@@ -0,0 +1,6 @@
+import type { BotMessageHandlerSettings } from "../../bot/message-handler/types.js";
+export type SafeSettings = ReturnType<typeof makeSettingsFrom>;
+export declare const makeSettingsFrom: (input: BotMessageHandlerSettings) => {
+    readonly limit: number;
+    readonly timeout: number;
+};

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

@@ -1,19 +1,8 @@
-import type { SetOptional } from "type-fest";
-export type BotConfig = {
-    token: string;
-    baseUrl: string;
-};
+import { ClientFileServiceInterface } from "./file/_service.js";
+import { Api } from "../specification/api.js";
+import type { TgBotClientSettingsInput } from "./guards.js";
 export type TgBotClient = ReturnType<typeof makeTgBotClient>;
-export declare const makeTgBotClient: (inputConfig: SetOptional<BotConfig, "baseUrl">) => {
-    readonly getFile: (input: {
-        file_id: string;
-    }) => 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]>>;
+export declare const makeTgBotClient: (input: TgBotClientSettingsInput) => {
+    execute: <M extends keyof Api>(method: M, input: Parameters<Api[M]>[0]) => Promise<ReturnType<Api[M]>>;
+    getFile: (input: Parameters<ClientFileServiceInterface["getFile"]>[0]) => Promise<File>;
 };

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

@@ -0,0 +1,8 @@
+import * as Context from "effect/Context";
+import { TgBotClientSettingsInput } from "./guards.js";
+export type TgBotClientConfigObject = Required<TgBotClientSettingsInput>;
+export declare const makeTgBotClientConfig: (input: TgBotClientSettingsInput) => Required<TgBotClientSettingsInput>;
+declare const TgBotClientConfig_base: Context.TagClass<TgBotClientConfig, "TgBotClientConfig", Required<TgBotClientSettingsInput>>;
+export declare class TgBotClientConfig extends TgBotClientConfig_base {
+}
+export {};

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

@@ -12,10 +12,12 @@ type ErrorReason = {
     readonly type: "UnableToGetFile";
     readonly cause: unknown;
 };
-export declare class TgBotClientError extends Error {
-    readonly reason: ErrorReason;
-    readonly _tag = "TgBotClientError";
-    constructor(reason: ErrorReason);
+declare const TgBotClientError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "TgBotClientError";
+} & Readonly<A>;
+export declare class TgBotClientError extends TgBotClientError_base<{
+    reason: ErrorReason;
+}> {
     static readonly missingSuccess: TgBotClientError;
 }
 export {};

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

@@ -0,0 +1,15 @@
+import * as Micro from "effect/Micro";
+import * as Context from "effect/Context";
+import type { Api } from "../../specification/api.js";
+import { TgBotClientError } from "../errors.js";
+import { TgBotClientConfig } from "../config.js";
+export type ClientExecuteRequestServiceInterface = Micro.Micro.Success<typeof ClientExecuteRequestServiceDefault>;
+declare const ClientExecuteRequestService_base: Context.TagClass<ClientExecuteRequestService, "ClientExecuteRequestService", {
+    execute: <M extends keyof Api>(method: M, input: Parameters<Api[M]>[0]) => Micro.Micro<ReturnType<Api[M]>, TgBotClientError>;
+}>;
+export declare class ClientExecuteRequestService extends ClientExecuteRequestService_base {
+}
+export declare const ClientExecuteRequestServiceDefault: Micro.Micro<{
+    readonly execute: <M extends keyof Api>(method: M, input: Parameters<Api[M]>[0]) => Micro.Micro<ReturnType<Api[M]>, TgBotClientError, never>;
+}, never, TgBotClientConfig>;
+export {};

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

@@ -0,0 +1,5 @@
+import * as Micro from "effect/Micro";
+import type { Api } from "../../specification/api.js";
+import { TgBotClientError } from "../errors.js";
+import { TgBotClientConfigObject } from "../config.js";
+export declare const execute: <M extends keyof Api>(config: TgBotClientConfigObject, method: M, input: Parameters<Api[M]>[0]) => Micro.Micro<ReturnType<Api[M]>, TgBotClientError>;

package/dist/dts/client/file/_service.d.ts

@@ -0,0 +1,16 @@
+import * as Micro from "effect/Micro";
+import * as Context from "effect/Context";
+import { TgBotClientConfig } from "../config.js";
+import { getFile } from "./get-file.js";
+export type ClientFileServiceInterface = Context.Tag.Service<typeof ClientFileService>;
+declare const ClientFileService_base: Context.TagClass<ClientFileService, "ClientFileService", {
+    getFile: (input: {
+        file_id: string;
+    }) => ReturnType<typeof getFile>;
+}>;
+export declare class ClientFileService extends ClientFileService_base {
+}
+export declare const ClientFileServiceDefault: Micro.Micro<{
+    readonly getFile: (input: Parameters<ClientFileServiceInterface["getFile"]>[0]) => Micro.Micro<File, import("../errors.js").TgBotClientError, never>;
+}, never, TgBotClientConfig>;
+export {};

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

@@ -0,0 +1,5 @@
+import * as Micro from "effect/Micro";
+import { TgBotClientError } from "../errors.js";
+import { TgBotClientConfigObject } from "../config.js";
+import { ClientExecuteRequestServiceInterface } from "../execute-request/_service.js";
+export declare const getFile: (fileId: string, config: TgBotClientConfigObject, execute: ClientExecuteRequestServiceInterface) => Micro.Micro<File, TgBotClientError>;

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

@@ -0,0 +1,17 @@
+export type FileContent = {
+    file_content: Uint8Array;
+    file_name: string;
+};
+export declare const isFileContent: (input: unknown) => input is FileContent;
+export type TgBotApiResponseSchema = {
+    ok: boolean;
+    error_code?: number;
+    description?: string;
+    result?: unknown;
+};
+export declare const isTgBotApiResponse: (input: unknown) => input is TgBotApiResponseSchema;
+export type TgBotClientSettingsInput = {
+    ["bot-token"]: string;
+    ["base-url"]?: string;
+};
+export declare const isTgBotClientSettingsInput: (input: unknown) => input is TgBotClientSettingsInput;

package/dist/dts/{client/const.d.ts → const.d.ts}

@@ -1,3 +1,4 @@
+export declare const defaultBaseUrl = "https://api.telegram.org";
 export declare const MESSAGE_EFFECTS: {
     readonly "\uD83D\uDD25": "5104841245755180586";
     readonly "\uD83D\uDC4D": "5107584321108051014";

package/dist/dts/index.d.ts

@@ -1,4 +1,5 @@
-export * from "./client/const.js";
 export * from "./client/_client.js";
+export * from "./bot/run.js";
 export * from "./specification/api.js";
 export * from "./specification/types.js";
+export * from "./const.js";