Effect-ification end to end

import { AuthMiddleware, ServerApi } from "@app/api"; // 👈 Shared API

import { Config, Context, Effect, Layer } from "effect";
import { FetchHttpClient, HttpClientRequest } from "effect/unstable/http";
import { HttpApiClient, HttpApiMiddleware } from "effect/unstable/httpapi";

class CurrentAccessToken extends Context.Service<CurrentAccessToken, string>()(
  "CurrentAccessToken"
) {}

const AuthMiddlewareClient = HttpApiMiddleware.layerClient(
  AuthMiddleware,
  Effect.fn(function* ({ next, request }) {
    const token = yield* CurrentAccessToken;
    return yield* next(HttpClientRequest.bearerToken(request, token));
  })
);

export class ApiClient extends Context.Service<ApiClient>()("ApiClient", {
  make: Effect.gen(function* () {
    const baseUrl = yield* Config.string("API_BASE_URL");

    return {
      withAccessToken: <A, E, R>(
        f: (
          api: HttpApiClient.ForApi<typeof ServerApi>
        ) => Effect.Effect<A, E, R>,
        accessToken: string
      ): Effect.Effect<A, E, Exclude<R, CurrentAccessToken>> =>
        Effect.gen(function* () {
          const api = yield* HttpApiClient.make(ServerApi, { baseUrl });
          return yield* f(api);
        }).pipe(
          Effect.provide(
            Layer.mergeAll(AuthMiddlewareClient, FetchHttpClient.layer),
          ),
          Effect.provideService(CurrentAccessToken, accessToken),
        ),
    };
  }),
}) {
  static readonly layer = Layer.effect(this, this.make);
}

import { createClerkClient } from "@clerk/backend";
import { Config, Context, Effect, Layer, Redacted, Schema } from "effect";

class ClerkError extends Schema.TaggedErrorClass<ClerkError>()("ClerkError", {
  cause: Schema.Unknown,
}) {}

export class Clerk extends Context.Service<Clerk>()("Clerk", {
  make: Effect.gen(function* () {
    const { publishableKey, secretKey } = yield* Config.all({
      publishableKey: Config.redacted("CLERK_PUBLISHABLE_KEY"),
      secretKey: Config.redacted("CLERK_SECRET_KEY"),
    });

    const clerkClient = createClerkClient({
      publishableKey: Redacted.value(publishableKey),
      secretKey: Redacted.value(secretKey),
    });

    return {
      authenticateRequest: (request: globalThis.Request) =>
        Effect.tryPromise({
          try: () => clerkClient.authenticateRequest(request),
          catch: (error) => new ClerkError({ cause: error }),
        }).pipe(
          Effect.timeout("5 seconds"),
          Effect.catchTag("TimeoutError", (cause) =>
            new ClerkError({ cause }).asEffect()
          )
        ),
    };
  }),
}) {
  static readonly layer = Layer.effect(this, this.make);
}