@effect-ak/tg-bot-client 1.0.0 → 1.2.0

package/dist/index.d.cts

@@ -1,60 +1,33 @@
-import * as Micro from 'effect/Micro';
-import { Api, Update } from '@effect-ak/tg-bot-api';
-import * as effect_Cause from 'effect/Cause';
-import * as effect_Types from 'effect/Types';
-import * as Data from 'effect/Data';
-import * as Context from 'effect/Context';
+import { Api } from '@effect-ak/tg-bot-api';
 
-type ErrorReason = Data.TaggedEnum<{
-    NotOkResponse: {
-        errorCode?: number;
-        details?: string;
-    };
-    UnexpectedResponse: {
-        response: unknown;
-    };
-    ClientInternalError: {
-        cause: unknown;
-    };
-    UnableToGetFile: {
-        cause: unknown;
-    };
-    BotHandlerError: {
-        cause: unknown;
-    };
-    NotJsonResponse: {
-        response: unknown;
-    };
-}>;
-declare const TgBotClientError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
-    readonly _tag: "TgBotClientError";
-} & Readonly<A>;
-declare class TgBotClientError extends TgBotClientError_base<{
-    cause: ErrorReason;
-}> {
+interface TgBotConfig {
+    botToken: string;
+    baseUrl?: string;
 }
+declare const getBaseUrl: (config?: Pick<TgBotConfig, "baseUrl">) => string;
 
-declare const TgBotApiBaseUrl_base: Context.ReferenceClass<TgBotApiBaseUrl, "TgBotApiBaseUrl", string>;
-declare class TgBotApiBaseUrl extends TgBotApiBaseUrl_base {
-}
-declare const TgBotApiToken_base: Context.TagClass<TgBotApiToken, "TgBotApiToken", string>;
-declare class TgBotApiToken extends TgBotApiToken_base {
-}
-
-declare const executeTgBotMethod: <M extends keyof Api>(method: M, input: Parameters<Api[M]>[0]) => Micro.Micro<ReturnType<Api[M]>, TgBotClientError, TgBotApiToken>;
+declare function executeTgBotMethod<M extends keyof Api>(params: {
+    config: TgBotConfig;
+    method: M;
+    input: Parameters<Api[M]>[0];
+}): Promise<ReturnType<Api[M]>>;
 declare const makePayload: (body: object) => FormData | undefined;
 
-declare const ClientFileService_base: Context.TagClass<ClientFileService, "ClientFileService", {
-    getFile: (input: GetFile) => ReturnType<typeof getFile>;
-}>;
-declare class ClientFileService extends ClientFileService_base {
-    static live: () => Context.Context<ClientFileService>;
-}
 interface GetFile {
     fileId: string;
     type?: string;
 }
-declare const getFile: ({ fileId, type }: GetFile) => Micro.Micro<File, TgBotClientError, TgBotApiToken>;
+interface FileBytes {
+    content: ArrayBuffer;
+    file_name: string;
+    base64String: () => string;
+}
+interface FileContext {
+    config: TgBotConfig;
+    execute: <M extends keyof Api>(method: M, input: Parameters<Api[M]>[0]) => Promise<ReturnType<Api[M]>>;
+}
+declare const getFileBytes: (fileId: string, context: FileContext) => Promise<FileBytes>;
+declare const getFile: (input: GetFile, context: FileContext) => Promise<File>;
 
 interface TgBotClient {
     readonly execute: <M extends keyof Api>(method: M, input: Parameters<Api[M]>[0]) => Promise<ReturnType<Api[M]>>;
@@ -62,9 +35,38 @@ interface TgBotClient {
 }
 interface MakeTgClient {
     bot_token: string;
+    base_url?: string;
 }
 declare function makeTgBotClient(config: MakeTgClient): TgBotClient;
 
+type ErrorReason = {
+    _tag: "NotOkResponse";
+    errorCode?: number;
+    details?: string;
+} | {
+    _tag: "UnexpectedResponse";
+    response: unknown;
+} | {
+    _tag: "ClientInternalError";
+    cause: unknown;
+} | {
+    _tag: "UnableToGetFile";
+    cause: unknown;
+} | {
+    _tag: "BotHandlerError";
+    cause: unknown;
+} | {
+    _tag: "NotJsonResponse";
+    response: unknown;
+};
+declare class TgBotClientError extends Error {
+    readonly _tag = "TgBotClientError";
+    readonly cause: ErrorReason;
+    constructor(options: {
+        cause: ErrorReason;
+    });
+}
+
 interface FileContent {
     file_content: Uint8Array<ArrayBuffer>;
     file_name: string;
@@ -77,7 +79,6 @@ interface TgBotApiResponseSchema {
     result?: unknown;
 }
 declare const isTgBotApiResponse: (input: unknown) => input is TgBotApiResponseSchema;
-declare const isTgBotApiUpdate: (input: unknown) => input is Update;
 
 declare const TG_BOT_API_URL = "https://api.telegram.org";
 declare const MESSAGE_EFFECTS: {
@@ -92,4 +93,6 @@ type MessageEffect = keyof typeof MESSAGE_EFFECTS;
 declare const messageEffectIdCodes: MessageEffect[];
 declare const isMessageEffect: (input: unknown) => input is MessageEffect;
 
-export { ClientFileService, type FileContent, type GetFile, MESSAGE_EFFECTS, type MessageEffect, TG_BOT_API_URL, TgBotApiBaseUrl, type TgBotApiResponseSchema, TgBotApiToken, type TgBotClient, TgBotClientError, executeTgBotMethod, isFileContent, isMessageEffect, isTgBotApiResponse, isTgBotApiUpdate, makePayload, makeTgBotClient, messageEffectIdCodes };
+declare const snakeToCamel: (str: string) => string;
+
+export { type FileBytes, type FileContent, type GetFile, MESSAGE_EFFECTS, type MakeTgClient, type MessageEffect, TG_BOT_API_URL, type TgBotApiResponseSchema, type TgBotClient, TgBotClientError, type TgBotConfig, executeTgBotMethod, getBaseUrl, getFile, getFileBytes, isFileContent, isMessageEffect, isTgBotApiResponse, makePayload, makeTgBotClient, messageEffectIdCodes, snakeToCamel };

package/dist/index.d.ts

@@ -1,60 +1,33 @@
-import * as Micro from 'effect/Micro';
-import { Api, Update } from '@effect-ak/tg-bot-api';
-import * as effect_Cause from 'effect/Cause';
-import * as effect_Types from 'effect/Types';
-import * as Data from 'effect/Data';
-import * as Context from 'effect/Context';
+import { Api } from '@effect-ak/tg-bot-api';
 
-type ErrorReason = Data.TaggedEnum<{
-    NotOkResponse: {
-        errorCode?: number;
-        details?: string;
-    };
-    UnexpectedResponse: {
-        response: unknown;
-    };
-    ClientInternalError: {
-        cause: unknown;
-    };
-    UnableToGetFile: {
-        cause: unknown;
-    };
-    BotHandlerError: {
-        cause: unknown;
-    };
-    NotJsonResponse: {
-        response: unknown;
-    };
-}>;
-declare const TgBotClientError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
-    readonly _tag: "TgBotClientError";
-} & Readonly<A>;
-declare class TgBotClientError extends TgBotClientError_base<{
-    cause: ErrorReason;
-}> {
+interface TgBotConfig {
+    botToken: string;
+    baseUrl?: string;
 }
+declare const getBaseUrl: (config?: Pick<TgBotConfig, "baseUrl">) => string;
 
-declare const TgBotApiBaseUrl_base: Context.ReferenceClass<TgBotApiBaseUrl, "TgBotApiBaseUrl", string>;
-declare class TgBotApiBaseUrl extends TgBotApiBaseUrl_base {
-}
-declare const TgBotApiToken_base: Context.TagClass<TgBotApiToken, "TgBotApiToken", string>;
-declare class TgBotApiToken extends TgBotApiToken_base {
-}
-
-declare const executeTgBotMethod: <M extends keyof Api>(method: M, input: Parameters<Api[M]>[0]) => Micro.Micro<ReturnType<Api[M]>, TgBotClientError, TgBotApiToken>;
+declare function executeTgBotMethod<M extends keyof Api>(params: {
+    config: TgBotConfig;
+    method: M;
+    input: Parameters<Api[M]>[0];
+}): Promise<ReturnType<Api[M]>>;
 declare const makePayload: (body: object) => FormData | undefined;
 
-declare const ClientFileService_base: Context.TagClass<ClientFileService, "ClientFileService", {
-    getFile: (input: GetFile) => ReturnType<typeof getFile>;
-}>;
-declare class ClientFileService extends ClientFileService_base {
-    static live: () => Context.Context<ClientFileService>;
-}
 interface GetFile {
     fileId: string;
     type?: string;
 }
-declare const getFile: ({ fileId, type }: GetFile) => Micro.Micro<File, TgBotClientError, TgBotApiToken>;
+interface FileBytes {
+    content: ArrayBuffer;
+    file_name: string;
+    base64String: () => string;
+}
+interface FileContext {
+    config: TgBotConfig;
+    execute: <M extends keyof Api>(method: M, input: Parameters<Api[M]>[0]) => Promise<ReturnType<Api[M]>>;
+}
+declare const getFileBytes: (fileId: string, context: FileContext) => Promise<FileBytes>;
+declare const getFile: (input: GetFile, context: FileContext) => Promise<File>;
 
 interface TgBotClient {
     readonly execute: <M extends keyof Api>(method: M, input: Parameters<Api[M]>[0]) => Promise<ReturnType<Api[M]>>;
@@ -62,9 +35,38 @@ interface TgBotClient {
 }
 interface MakeTgClient {
     bot_token: string;
+    base_url?: string;
 }
 declare function makeTgBotClient(config: MakeTgClient): TgBotClient;
 
+type ErrorReason = {
+    _tag: "NotOkResponse";
+    errorCode?: number;
+    details?: string;
+} | {
+    _tag: "UnexpectedResponse";
+    response: unknown;
+} | {
+    _tag: "ClientInternalError";
+    cause: unknown;
+} | {
+    _tag: "UnableToGetFile";
+    cause: unknown;
+} | {
+    _tag: "BotHandlerError";
+    cause: unknown;
+} | {
+    _tag: "NotJsonResponse";
+    response: unknown;
+};
+declare class TgBotClientError extends Error {
+    readonly _tag = "TgBotClientError";
+    readonly cause: ErrorReason;
+    constructor(options: {
+        cause: ErrorReason;
+    });
+}
+
 interface FileContent {
     file_content: Uint8Array<ArrayBuffer>;
     file_name: string;
@@ -77,7 +79,6 @@ interface TgBotApiResponseSchema {
     result?: unknown;
 }
 declare const isTgBotApiResponse: (input: unknown) => input is TgBotApiResponseSchema;
-declare const isTgBotApiUpdate: (input: unknown) => input is Update;
 
 declare const TG_BOT_API_URL = "https://api.telegram.org";
 declare const MESSAGE_EFFECTS: {
@@ -92,4 +93,6 @@ type MessageEffect = keyof typeof MESSAGE_EFFECTS;
 declare const messageEffectIdCodes: MessageEffect[];
 declare const isMessageEffect: (input: unknown) => input is MessageEffect;
 
-export { ClientFileService, type FileContent, type GetFile, MESSAGE_EFFECTS, type MessageEffect, TG_BOT_API_URL, TgBotApiBaseUrl, type TgBotApiResponseSchema, TgBotApiToken, type TgBotClient, TgBotClientError, executeTgBotMethod, isFileContent, isMessageEffect, isTgBotApiResponse, isTgBotApiUpdate, makePayload, makeTgBotClient, messageEffectIdCodes };
+declare const snakeToCamel: (str: string) => string;
+
+export { type FileBytes, type FileContent, type GetFile, MESSAGE_EFFECTS, type MakeTgClient, type MessageEffect, TG_BOT_API_URL, type TgBotApiResponseSchema, type TgBotClient, TgBotClientError, type TgBotConfig, executeTgBotMethod, getBaseUrl, getFile, getFileBytes, isFileContent, isMessageEffect, isTgBotApiResponse, makePayload, makeTgBotClient, messageEffectIdCodes, snakeToCamel };

package/dist/index.js

@@ -1,19 +1,17 @@
-// src/execute.ts
-import * as String from "effect/String";
-import * as Micro from "effect/Micro";
-
 // src/errors.ts
-import * as Data from "effect/Data";
-var TgBotClientError = class extends Data.TaggedError("TgBotClientError") {
+var TgBotClientError = class extends Error {
+  _tag = "TgBotClientError";
+  cause;
+  constructor(options) {
+    super(`TgBotClientError: ${options.cause._tag}`);
+    this.cause = options.cause;
+    this.name = "TgBotClientError";
+  }
 };
 
 // src/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 isTgBotApiUpdate = (input) => typeof input == "object" && input != null && "update_id" in input && typeof input.update_id == "number";
-
-// src/config.ts
-import * as Context from "effect/Context";
 
 // src/const.ts
 var TG_BOT_API_URL = "https://api.telegram.org";
@@ -33,53 +31,58 @@ var isMessageEffect = (input) => {
 };
 
 // src/config.ts
-var TgBotApiBaseUrl = class extends Context.Reference()(
-  "TgBotApiBaseUrl",
-  { defaultValue: () => TG_BOT_API_URL }
-) {
+var getBaseUrl = (config) => {
+  return config?.baseUrl ?? TG_BOT_API_URL;
 };
-var TgBotApiToken = class extends Context.Tag("TgBotApiToken")() {
+
+// src/utils.ts
+var snakeToCamel = (str) => {
+  return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
 };
 
 // src/execute.ts
-var executeTgBotMethod = (method, input) => Micro.gen(function* () {
-  const botToken = yield* Micro.service(TgBotApiToken);
-  const baseUrl = yield* Micro.service(TgBotApiBaseUrl);
-  const httpResponse = yield* Micro.tryPromise({
-    try: () => fetch(`${baseUrl}/bot${botToken}/${String.snakeToCamel(method)}`, {
-      body: makePayload(input) ?? null,
-      method: "POST"
-    }),
-    catch: (cause) => new TgBotClientError({
+async function executeTgBotMethod(params) {
+  const { config, method, input } = params;
+  const baseUrl = getBaseUrl(config);
+  const botToken = config.botToken;
+  let httpResponse;
+  try {
+    httpResponse = await fetch(
+      `${baseUrl}/bot${botToken}/${snakeToCamel(method)}`,
+      {
+        body: makePayload(input) ?? null,
+        method: "POST"
+      }
+    );
+  } catch (cause) {
+    throw new TgBotClientError({
       cause: { _tag: "ClientInternalError", cause }
-    })
-  });
-  const response = yield* Micro.tryPromise({
-    try: () => httpResponse.json(),
-    catch: () => new TgBotClientError({
+    });
+  }
+  let response;
+  try {
+    response = await httpResponse.json();
+  } catch {
+    throw new TgBotClientError({
       cause: { _tag: "NotJsonResponse", response: httpResponse }
-    })
-  });
+    });
+  }
   if (!isTgBotApiResponse(response)) {
-    return yield* Micro.fail(
-      new TgBotClientError({
-        cause: { _tag: "UnexpectedResponse", response }
-      })
-    );
+    throw new TgBotClientError({
+      cause: { _tag: "UnexpectedResponse", response }
+    });
   }
   if (!httpResponse.ok) {
-    return yield* Micro.fail(
-      new TgBotClientError({
-        cause: {
-          _tag: "NotOkResponse",
-          ...response.error_code ? { errorCode: response.error_code } : void 0,
-          ...response.description ? { details: response.description } : void 0
-        }
-      })
-    );
+    throw new TgBotClientError({
+      cause: {
+        _tag: "NotOkResponse",
+        ...response.error_code ? { errorCode: response.error_code } : {},
+        ...response.description ? { details: response.description } : {}
+      }
+    });
   }
   return response.result;
-});
+}
 var makePayload = (body) => {
   const entries = Object.entries(body);
   if (entries.length == 0) return void 0;
@@ -98,83 +101,69 @@ var makePayload = (body) => {
 };
 
 // src/client-file.ts
-import * as Micro2 from "effect/Micro";
-import * as Context2 from "effect/Context";
-var ClientFileService = class _ClientFileService extends Context2.Tag("ClientFileService")() {
-  static live = () => {
-    return _ClientFileService.context({
-      getFile
-    });
-  };
-};
-var getFile = ({ fileId, type }) => getFileBytes(fileId).pipe(
-  Micro2.andThen(
-    ({ content, file_name }) => new File([content], file_name, {
-      ...type ? { type } : void 0
-    })
-  )
-);
-var getFileBytes = (fileId) => Micro2.gen(function* () {
-  const response = yield* executeTgBotMethod("get_file", { file_id: fileId });
+var getFileBytes = async (fileId, context) => {
+  const { config, execute } = context;
+  const response = await execute("get_file", { file_id: fileId });
   const file_path = response.file_path;
-  if (!file_path || file_path.length == 0) {
-    return yield* Micro2.fail(
-      new TgBotClientError({
-        cause: {
-          _tag: "UnableToGetFile",
-          cause: "File path not defined"
-        }
-      })
-    );
+  if (!file_path || file_path.length === 0) {
+    throw new TgBotClientError({
+      cause: {
+        _tag: "UnableToGetFile",
+        cause: "File path not defined"
+      }
+    });
   }
   const file_name = file_path.replaceAll("/", "-");
-  const baseUrl = yield* Micro2.service(TgBotApiBaseUrl);
-  const botToken = yield* Micro2.service(TgBotApiToken);
+  const baseUrl = getBaseUrl(config);
+  const botToken = config.botToken;
   const url = `${baseUrl}/file/bot${botToken}/${file_path}`;
-  const content = yield* Micro2.tryPromise({
-    try: () => fetch(url).then((_) => _.arrayBuffer()),
-    catch: (cause) => new TgBotClientError({
+  let content;
+  try {
+    content = await fetch(url).then((_) => _.arrayBuffer());
+  } catch (cause) {
+    throw new TgBotClientError({
       cause: { _tag: "UnableToGetFile", cause }
-    })
-  });
+    });
+  }
+  const base64String = () => Buffer.from(content).toString("base64");
   return {
     content,
-    file_name
+    file_name,
+    base64String
   };
-});
+};
+var getFile = async (input, context) => {
+  const { content, file_name } = await getFileBytes(input.fileId, context);
+  return new File([content], file_name, {
+    ...input.type ? { type: input.type } : {}
+  });
+};
 
 // src/client.ts
-import * as Micro3 from "effect/Micro";
-import * as Context3 from "effect/Context";
 function makeTgBotClient(config) {
-  return createEffect(config).pipe(Micro3.runSync);
-}
-var createEffect = ({ bot_token }) => Micro3.gen(function* () {
-  const file = yield* Micro3.service(ClientFileService);
-  const context = Context3.make(TgBotApiToken, bot_token);
-  const execute = (method, input) => executeTgBotMethod(method, input).pipe(
-    Micro3.provideContext(context),
-    Micro3.runPromise
-  );
-  const getFile2 = (input) => file.getFile(input).pipe(Micro3.provideContext(context), Micro3.runPromise);
+  const tgConfig = {
+    botToken: config.bot_token,
+    ...config.base_url ? { baseUrl: config.base_url } : {}
+  };
+  const execute = (method, input) => executeTgBotMethod({ config: tgConfig, method, input });
   return {
     execute,
-    getFile: getFile2
+    getFile: (input) => getFile(input, { config: tgConfig, execute })
   };
-}).pipe(Micro3.provideContext(ClientFileService.live()));
+}
 export {
-  ClientFileService,
   MESSAGE_EFFECTS,
   TG_BOT_API_URL,
-  TgBotApiBaseUrl,
-  TgBotApiToken,
   TgBotClientError,
   executeTgBotMethod,
+  getBaseUrl,
+  getFile,
+  getFileBytes,
   isFileContent,
   isMessageEffect,
   isTgBotApiResponse,
-  isTgBotApiUpdate,
   makePayload,
   makeTgBotClient,
-  messageEffectIdCodes
+  messageEffectIdCodes,
+  snakeToCamel
 };

package/package.json

@@ -2,7 +2,7 @@
   "name": "@effect-ak/tg-bot-client",
   "type": "module",
   "description": "Type-safe HTTP client for Telegram Bot API",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "license": "MIT",
   "author": {
     "name": "Aleksandr Kondaurov",
@@ -32,9 +32,6 @@
   "dependencies": {
     "@effect-ak/tg-bot-api": "0.9.2"
   },
-  "peerDependencies": {
-    "effect": "^3.12.0"
-  },
   "scripts": {
     "build": "tsup"
   }

package/src/client-file.ts

@@ -1,70 +1,73 @@
-import * as Micro from "effect/Micro"
-import * as Context from "effect/Context"
-
+import type { Api } from "@effect-ak/tg-bot-api"
 import { TgBotClientError } from "./errors"
-import { TgBotApiBaseUrl, TgBotApiToken } from "./config"
-import { executeTgBotMethod } from "./execute"
-
-export class ClientFileService extends Context.Tag("ClientFileService")<
-  ClientFileService,
-  {
-    getFile: (input: GetFile) => ReturnType<typeof getFile>
-  }
->() {
-  static live = () => {
-    return ClientFileService.context({
-      getFile
-    })
-  }
-}
+import type { TgBotConfig } from "./config"
+import { getBaseUrl } from "./config"
 
 export interface GetFile {
   fileId: string
   type?: string
 }
 
-const getFile = ({ fileId, type }: GetFile) =>
-  getFileBytes(fileId).pipe(
-    Micro.andThen(
-      ({ content, file_name }) =>
-        new File([content], file_name, {
-          ...(type ? { type } : undefined)
-        })
-    )
-  )
+export interface FileBytes {
+  content: ArrayBuffer
+  file_name: string
+  base64String: () => string
+}
 
-const getFileBytes = (fileId: string) =>
-  Micro.gen(function* () {
-    const response = yield* executeTgBotMethod("get_file", { file_id: fileId })
-    const file_path = response.file_path
+interface FileContext {
+  config: TgBotConfig
+  execute: <M extends keyof Api>(
+    method: M,
+    input: Parameters<Api[M]>[0]
+  ) => Promise<ReturnType<Api[M]>>
+}
 
-    if (!file_path || file_path.length == 0) {
-      return yield* Micro.fail(
-        new TgBotClientError({
-          cause: {
-            _tag: "UnableToGetFile",
-            cause: "File path not defined"
-          }
-        })
-      )
-    }
+export const getFileBytes = async (
+  fileId: string,
+  context: FileContext
+): Promise<FileBytes> => {
+  const { config, execute } = context
+  const response = await execute("get_file", { file_id: fileId })
+  const file_path = response.file_path
 
-    const file_name = file_path.replaceAll("/", "-")
-    const baseUrl = yield* Micro.service(TgBotApiBaseUrl)
-    const botToken = yield* Micro.service(TgBotApiToken)
+  if (!file_path || file_path.length === 0) {
+    throw new TgBotClientError({
+      cause: {
+        _tag: "UnableToGetFile",
+        cause: "File path not defined"
+      }
+    })
+  }
 
-    const url = `${baseUrl}/file/bot${botToken}/${file_path}`
+  const file_name = file_path.replaceAll("/", "-")
+  const baseUrl = getBaseUrl(config)
+  const botToken = config.botToken
+  const url = `${baseUrl}/file/bot${botToken}/${file_path}`
 
-    const content = yield* Micro.tryPromise({
-      try: () => fetch(url).then((_) => _.arrayBuffer()),
-      catch: (cause) =>
-        new TgBotClientError({
-          cause: { _tag: "UnableToGetFile", cause }
-        })
+  let content: ArrayBuffer
+  try {
+    content = await fetch(url).then((_) => _.arrayBuffer())
+  } catch (cause) {
+    throw new TgBotClientError({
+      cause: { _tag: "UnableToGetFile", cause }
     })
+  }
+
+  const base64String = () => Buffer.from(content).toString("base64")
 
-    return {
-      content,
-      file_name
-    }
+  return {
+    content,
+    file_name,
+    base64String
+  }
+}
+
+export const getFile = async (
+  input: GetFile,
+  context: FileContext
+): Promise<File> => {
+  const { content, file_name } = await getFileBytes(input.fileId, context)
+  return new File([content], file_name, {
+    ...(input.type ? { type: input.type } : {})
   })
+}