fix: resolve cyclic dependencies

Author: evermake

src/BotApi.ts

@@ -1,10 +1,10 @@
-import type * as Layer from 'effect/Layer'
 import type { BotApiTransport } from './BotApiTransport.ts'
 import type { MethodParams, MethodResults } from './internal/botApiMethods.gen.ts'
 import type { BotApiShape } from './internal/botApiShape.gen.ts'
 import type * as Types from './internal/botApiTypes.gen.ts'
 import * as Context from 'effect/Context'
 import * as Data from 'effect/Data'
+import * as Layer from 'effect/Layer'
 import * as internal from './internal/botApi.ts'
 
 export type { MethodParams, MethodResults, Types }
@@ -27,4 +27,8 @@ export class BotApiError extends Data.TaggedError('@grom.js/effect-tg/BotApiErro
   }
 }
 
-export const layer: Layer.Layer<BotApi, never, BotApiTransport> = internal.layer
+export const layer: Layer.Layer<
+  BotApi,
+  never,
+  BotApiTransport
+> = Layer.effect(BotApi, internal.make)

src/BotApiTransport.ts

@@ -2,6 +2,7 @@ import type * as Effect from 'effect/Effect'
 import type * as Types from './internal/botApiTypes.gen.ts'
 import * as Context from 'effect/Context'
 import * as Data from 'effect/Data'
+import * as Layer from 'effect/Layer'
 import * as internal from './internal/botApiTransport.ts'
 
 export class BotApiTransport extends Context.Tag('@grom.js/effect-tg/BotApiTransport')<
@@ -37,7 +38,9 @@ export class BotApiTransportError extends Data.TaggedError('@grom.js/effect-tg/B
   cause: unknown
 }> {}
 
-export const layerWith = internal.layerWith
+export const layerWith = (options: {
+  makeUrl: (method: string) => URL
+}) => Layer.effect(BotApiTransport, internal.makeWith(options))
 
 export const layerProd = (token: string) => (
   layerWith({

src/internal/botApi.ts

@@ -1,36 +1,32 @@
 import type { BotApiShape } from './botApiShape.gen.ts'
 import * as Effect from 'effect/Effect'
-import * as Layer from 'effect/Layer'
-import { BotApi, BotApiError } from '../BotApi.ts'
+import { BotApiError } from '../BotApi.ts'
 import { BotApiTransport } from '../BotApiTransport.ts'
 
-export const layer = Layer.effect(
-  BotApi,
-  Effect.gen(function* () {
-    const transport = yield* BotApiTransport
-    const botApi = new Proxy({}, {
-      get: (_target, prop) => {
-        if (typeof prop !== 'string') {
-          return
-        }
-        const method = prop
-        return (params: void | Record<string, unknown> = {}) => (
-          Effect.gen(function* () {
-            const response = yield* transport.sendRequest(method, params)
-            if (response.ok) {
-              return response.result
-            }
-            yield* Effect.fail(
-              new BotApiError({
-                code: response.error_code,
-                description: response.description,
-                parameters: response.parameters,
-              }),
-            )
-          })
-        )
-      },
-    })
-    return botApi as BotApiShape
-  }),
-)
+export const make = Effect.gen(function* () {
+  const transport = yield* BotApiTransport
+  const botApi = new Proxy({}, {
+    get: (_target, prop) => {
+      if (typeof prop !== 'string') {
+        return
+      }
+      const method = prop
+      return (params: void | Record<string, unknown> = {}) => (
+        Effect.gen(function* () {
+          const response = yield* transport.sendRequest(method, params)
+          if (response.ok) {
+            return response.result
+          }
+          yield* Effect.fail(
+            new BotApiError({
+              code: response.error_code,
+              description: response.description,
+              parameters: response.parameters,
+            }),
+          )
+        })
+      )
+    },
+  })
+  return botApi as BotApiShape
+})

src/internal/botApiTransport.ts

@@ -1,35 +1,34 @@
-import type { BotApiResponse } from '../BotApiTransport.ts'
+import type { BotApiResponse, BotApiTransport } from '../BotApiTransport.ts'
 import * as HttpBody from '@effect/platform/HttpBody'
 import * as HttpClient from '@effect/platform/HttpClient'
 import * as Effect from 'effect/Effect'
-import * as Layer from 'effect/Layer'
-import { BotApiTransport, BotApiTransportError } from '../BotApiTransport.ts'
+import { BotApiTransportError } from '../BotApiTransport.ts'
 
-export const layerWith = (options: {
+export const makeWith = (options: {
   makeUrl: (method: string) => URL
-}) => Layer.effect(
-  BotApiTransport,
-  Effect.gen(function* () {
-    const { makeUrl } = options
-    const client = yield* HttpClient.HttpClient
-    const transport: typeof BotApiTransport.Service = {
-      sendRequest: (method, params) => (
-        Effect
-          .gen(function* () {
-            const url = makeUrl(method)
-            // TODO: Serialize necessary parameters and handle file uploads.
-            const body = yield* HttpBody.json(params)
-            const response = yield* client.post(url, { body })
-            const responseJson = yield* response.json
-            return responseJson as BotApiResponse
-          })
-          .pipe(
-            Effect.catchAll(error => (
-              Effect.fail(new BotApiTransportError({ cause: error }))
-            )),
-          )
-      ),
-    }
-    return transport
-  }),
-)
+}): Effect.Effect<
+  typeof BotApiTransport.Service,
+  never,
+  HttpClient.HttpClient
+> => Effect.gen(function* () {
+  const { makeUrl } = options
+  const client = yield* HttpClient.HttpClient
+  return {
+    sendRequest: (method, params) => (
+      Effect
+        .gen(function* () {
+          const url = makeUrl(method)
+          // TODO: Serialize necessary parameters and handle file uploads.
+          const body = yield* HttpBody.json(params)
+          const response = yield* client.post(url, { body })
+          const responseJson = yield* response.json
+          return responseJson as BotApiResponse
+        })
+        .pipe(
+          Effect.catchAll(error => (
+            Effect.fail(new BotApiTransportError({ cause: error }))
+          )),
+        )
+    ),
+  }
+})