alchemy-effect 0.6.0 → 0.6.2

package/src/Cloudflare/Workers/Fetch.ts

@@ -0,0 +1,142 @@
+import type * as runtime from "@cloudflare/workers-types";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Result from "effect/Result";
+import * as Stream from "effect/Stream";
+import * as HttpClientError from "effect/unstable/http/HttpClientError";
+import * as HttpClientRequest from "effect/unstable/http/HttpClientRequest";
+import * as HttpClientResponse from "effect/unstable/http/HttpClientResponse";
+import * as UrlParams from "effect/unstable/http/UrlParams";
+import * as Binding from "../../Binding.ts";
+import { isWorker, type Worker, WorkerEnvironment } from "./Worker.ts";
+
+export class Fetch extends Binding.Service<
+  Fetch,
+  (
+    worker: Worker,
+  ) => Effect.Effect<
+    (
+      request: HttpClientRequest.HttpClientRequest,
+    ) => Effect.Effect<
+      HttpClientResponse.HttpClientResponse,
+      HttpClientError.RequestError
+    >
+  >
+>()("Cloudflare.Fetch") {}
+
+export const FetchLive = Layer.effect(
+  Fetch,
+  Effect.gen(function* () {
+    const Policy = yield* FetchPolicy;
+    const env = yield* WorkerEnvironment;
+
+    return Effect.fn(function* (worker: Worker) {
+      yield* Policy(worker);
+      const fetcher = (env as Record<string, runtime.Fetcher>)[
+        worker.LogicalId
+      ];
+
+      return (request: HttpClientRequest.HttpClientRequest) =>
+        doFetch(fetcher, request);
+    });
+  }),
+);
+
+const doFetch = (
+  fetcher: runtime.Fetcher,
+  request: HttpClientRequest.HttpClientRequest,
+): Effect.Effect<
+  HttpClientResponse.HttpClientResponse,
+  HttpClientError.RequestError
+> => {
+  const urlResult = UrlParams.makeUrl(
+    request.url,
+    request.urlParams,
+    request.hash.pipe(Option.getOrUndefined),
+  );
+  if (Result.isFailure(urlResult)) {
+    return Effect.fail(
+      new HttpClientError.InvalidUrlError({
+        request,
+        cause: urlResult.failure,
+        description: "Failed to construct URL",
+      }),
+    );
+  }
+  const url = urlResult.success;
+
+  const send = (body: BodyInit | undefined) =>
+    Effect.mapError(
+      Effect.map(
+        Effect.tryPromise({
+          try: () =>
+            fetcher.fetch(
+              url.toString() as runtime.RequestInfo,
+              {
+                method: request.method,
+                headers: request.headers as unknown as runtime.HeadersInit,
+                body,
+                duplex: request.body._tag === "Stream" ? "half" : undefined,
+              } as runtime.RequestInit,
+            ) as unknown as Promise<Response>,
+          catch: (cause) => cause,
+        }),
+        (response) => HttpClientResponse.fromWeb(request, response),
+      ),
+      (cause) =>
+        new HttpClientError.TransportError({
+          request,
+          cause,
+          description: "Service binding fetch failed",
+        }),
+    );
+
+  switch (request.body._tag) {
+    case "Raw":
+    case "Uint8Array":
+      return send(request.body.body as BodyInit);
+    case "FormData":
+      return send(request.body.formData);
+    case "Stream":
+      return Effect.flatMap(
+        Effect.mapError(
+          Stream.toReadableStreamEffect(request.body.stream),
+          (cause) =>
+            new HttpClientError.EncodeError({
+              request,
+              cause,
+              description: "Failed to encode stream body",
+            }),
+        ),
+        send,
+      );
+    default:
+      return send(undefined);
+  }
+};
+
+export class FetchPolicy extends Binding.Policy<
+  FetchPolicy,
+  (worker: Worker) => Effect.Effect<void>
+>()("Cloudflare.Fetch") {}
+
+export const FetchPolicyLive = FetchPolicy.layer.succeed(
+  Effect.fn(function* (host) {
+    if (isWorker(host)) {
+      yield* host.bind`Bind(${host})`({
+        bindings: [
+          {
+            type: "service",
+            name: host.LogicalId,
+            service: host.workerName,
+          },
+        ],
+      });
+    } else {
+      return yield* Effect.die(
+        new Error(`FetchPolicy does not support runtime '${host.Type}'`),
+      );
+    }
+  }),
+);

package/src/Cloudflare/Workers/Fetcher.ts

@@ -0,0 +1,280 @@
+import type * as cf from "@cloudflare/workers-types";
+import * as Deferred from "effect/Deferred";
+import * as Effect from "effect/Effect";
+import * as FiberSet from "effect/FiberSet";
+import { pipe } from "effect/Function";
+import * as Latch from "effect/Latch";
+import * as Scope from "effect/Scope";
+import * as HttpBody from "effect/unstable/http/HttpBody";
+import { HttpClientError } from "effect/unstable/http/HttpClientError";
+import * as HttpClientRequest from "effect/unstable/http/HttpClientRequest";
+import * as HttpClientResponse from "effect/unstable/http/HttpClientResponse";
+import type { HttpServerError } from "effect/unstable/http/HttpServerError";
+import * as HttpServerRequest from "effect/unstable/http/HttpServerRequest";
+import * as HttpServerResponse from "effect/unstable/http/HttpServerResponse";
+import * as Socket from "effect/unstable/socket/Socket";
+
+export type SocketAddress = cf.SocketAddress;
+
+export type SocketOptions = cf.SocketOptions;
+
+export interface Fetcher {
+  fetch(
+    request: HttpClientRequest.HttpClientRequest,
+  ): Effect.Effect<HttpClientResponse.HttpClientResponse, HttpClientError>;
+  fetch(
+    request: HttpServerRequest.HttpServerRequest,
+  ): Effect.Effect<HttpServerResponse.HttpServerResponse, HttpServerError>;
+
+  connect(
+    address: SocketAddress | string,
+    options?: SocketOptions,
+  ): Socket.Socket;
+}
+
+export const toCloudflareFetcher = Effect.fnUntraced(function* (
+  fetcher: Fetcher,
+) {
+  const services = yield* Effect.services();
+  return {
+    fetch: (input, init) =>
+      fetcher
+        .fetch(
+          HttpServerRequest.fromWeb(
+            new Request(input as any, init as any) as any as Request,
+          ),
+        )
+        .pipe(
+          Effect.map(
+            (response) =>
+              HttpServerResponse.toWeb(response, {
+                services,
+              }) as any as cf.Response,
+          ),
+          Effect.provideServices(services),
+          Effect.runPromise,
+        ),
+    connect() {
+      // TODO
+      throw new Error("toCloudflareFetcher does not support connect()");
+    },
+  } satisfies cf.Fetcher;
+});
+
+export const fromCloudflareFetcher = (fetcher: cf.Fetcher): Fetcher => {
+  const fetch = (request: Request) =>
+    Effect.promise((signal) =>
+      fetcher.fetch(request as any as cf.Request, {
+        signal: signal as cf.AbortSignal,
+      }),
+    );
+
+  return {
+    connect: (address, options) =>
+      fromCloudflareSocket(fetcher.connect(address, options)),
+    fetch: (
+      request:
+        | HttpClientRequest.HttpClientRequest
+        | HttpServerRequest.HttpServerRequest,
+    ): any =>
+      HttpClientRequest.isHttpClientRequest(request)
+        ? pipe(
+            HttpServerRequest.toWeb(
+              HttpServerRequest.fromClientRequest(request),
+            ),
+            Effect.flatMap(fetch),
+            Effect.map((response) =>
+              HttpClientResponse.fromWeb(request, response as any as Response),
+            ),
+            Effect.catch((error) =>
+              Effect.succeed(
+                HttpClientResponse.fromWeb(
+                  request,
+                  new Response(error.message, {
+                    status:
+                      error._tag === "InternalError"
+                        ? 500
+                        : error._tag === "RequestParseError"
+                          ? 400
+                          : 404,
+                  }),
+                ),
+              ),
+            ),
+          )
+        : pipe(
+            HttpServerRequest.toWeb(request),
+            Effect.flatMap(fetch),
+            Effect.map((response) => {
+              if ((response as any).status === 101) {
+                return HttpServerResponse.setBody(
+                  HttpServerResponse.empty({ status: 101 }),
+                  HttpBody.raw(response),
+                );
+              }
+              return HttpServerResponse.fromWeb(response as any as Response);
+            }),
+          ),
+  };
+};
+
+export const fromCloudflareSocket = (cfSocket: cf.Socket): Socket.Socket => {
+  const latch = Latch.makeUnsafe(false);
+  let currentFiberSet: FiberSet.FiberSet<any, any> | undefined;
+  let writerRef: WritableStreamDefaultWriter<Uint8Array> | undefined;
+  const encoder = new TextEncoder();
+  const closeError = (code: number, closeReason?: string) =>
+    new Socket.SocketError({
+      reason: new Socket.SocketCloseError({ code, closeReason }),
+    });
+
+  const runRaw = <_, E, R>(
+    handler: (_: string | Uint8Array) => Effect.Effect<_, E, R> | void,
+    opts?: { readonly onOpen?: Effect.Effect<void> | undefined },
+  ): Effect.Effect<void, Socket.SocketError | E, R> =>
+    Effect.scopedWith(
+      Effect.fnUntraced(function* (scope) {
+        // Cloudflare exposes connection establishment as a promise rather than an
+        // event emitter, so we normalize that into the same SocketOpenError shape
+        // Effect uses for the official adapters.
+        yield* Effect.tryPromise({
+          try: () => cfSocket.opened,
+          catch: (cause) =>
+            new Socket.SocketError({
+              reason: new Socket.SocketOpenError({
+                kind: "Unknown",
+                cause,
+              }),
+            }),
+        });
+
+        const reader = cfSocket.readable.getReader();
+        // Mirror `fromTransformStream`: the reader is scoped to a single `runRaw`
+        // invocation and is always cancelled when that scope closes.
+        yield* Scope.addFinalizer(
+          scope,
+          Effect.promise(() => reader.cancel()),
+        );
+
+        const fiberSet = yield* FiberSet.make<
+          any,
+          E | Socket.SocketError
+        >().pipe(Scope.provide(scope));
+        const runFork = yield* FiberSet.runtime(fiberSet)<R>();
+
+        // Keep the remote-close watcher inside the FiberSet instead of attaching a
+        // raw `.then(...)` callback. That matches Effect's pattern of keeping all
+        // background work scoped and lets `FiberSet.join` observe close outcomes.
+        yield* Effect.tryPromise({
+          try: async () => {
+            await cfSocket.closed;
+            throw closeError(1000);
+          },
+          catch: (cause) =>
+            Socket.isSocketError(cause) ? cause : closeError(1006),
+        }).pipe(FiberSet.run(fiberSet));
+
+        // The read loop itself follows `fromTransformStream`: fork the loop into
+        // the FiberSet so handler effects can run concurrently while `join`
+        // remains the single completion point for the socket session.
+        yield* Effect.tryPromise({
+          try: async () => {
+            while (true) {
+              const { done, value } = await reader.read();
+              if (done) {
+                throw closeError(1000);
+              }
+              const result = handler(value);
+              if (Effect.isEffect(result)) {
+                runFork(result);
+              }
+            }
+          },
+          catch: (cause) =>
+            Socket.isSocketError(cause)
+              ? cause
+              : new Socket.SocketError({
+                  reason: new Socket.SocketReadError({ cause }),
+                }),
+        }).pipe(FiberSet.run(fiberSet));
+
+        currentFiberSet = fiberSet;
+        // Writers are gated on the latch exactly like the official adapters so a
+        // caller cannot send data before the read side has been fully installed.
+        latch.openUnsafe();
+        if (opts?.onOpen) yield* opts.onOpen;
+
+        return yield* Effect.catchFilter(
+          FiberSet.join(fiberSet),
+          Socket.SocketCloseError.filterClean(
+            (code) => code === 1000 || code === 1006,
+          ),
+          () => Effect.void,
+        );
+      }),
+    ).pipe(
+      Effect.ensuring(
+        Effect.sync(() => {
+          latch.closeUnsafe();
+          currentFiberSet = undefined;
+        }),
+      ),
+    );
+
+  const run = <_, E, R>(
+    handler: (_: Uint8Array) => Effect.Effect<_, E, R> | void,
+    opts?: { readonly onOpen?: Effect.Effect<void> | undefined },
+  ): Effect.Effect<void, Socket.SocketError | E, R> =>
+    runRaw(
+      (data) =>
+        typeof data === "string"
+          ? handler(encoder.encode(data))
+          : handler(data),
+      opts,
+    );
+
+  const write = (
+    chunk: Uint8Array | string | Socket.CloseEvent,
+  ): Effect.Effect<void, Socket.SocketError> =>
+    latch.whenOpen(
+      Effect.suspend(() => {
+        if (Socket.isCloseEvent(chunk)) {
+          // `fromTransformStream` signals a local close by completing the
+          // FiberSet's deferred rather than trying to force stream semantics that
+          // don't exist. We do the same here so `runRaw` unwinds through `join`.
+          return Deferred.fail(
+            currentFiberSet!.deferred,
+            closeError(chunk.code, chunk.reason),
+          );
+        }
+        if (!writerRef) {
+          writerRef = cfSocket.writable.getWriter();
+        }
+        const data = typeof chunk === "string" ? encoder.encode(chunk) : chunk;
+        return Effect.tryPromise({
+          try: () => writerRef!.write(data),
+          catch: (cause) =>
+            new Socket.SocketError({
+              reason: new Socket.SocketWriteError({ cause }),
+            }),
+        });
+      }),
+    );
+
+  const writer = Effect.acquireRelease(Effect.succeed(write), () =>
+    // Treat writer shutdown as best-effort cleanup. Cloudflare may already have
+    // closed the writable side by the time the scope releases.
+    Effect.promise(async () => {
+      if (writerRef) {
+        await writerRef.close().catch(() => {});
+      }
+    }),
+  );
+
+  return Socket.Socket.of({
+    [Socket.TypeId]: Socket.TypeId,
+    run,
+    runRaw,
+    writer,
+  });
+};

package/src/Cloudflare/Workers/HttpServer.ts

@@ -0,0 +1,159 @@
+import type * as cf from "@cloudflare/workers-types";
+import * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import type { Scope } from "effect/Scope";
+import type { HttpBodyError } from "effect/unstable/http/HttpBody";
+import * as HttpServerError from "effect/unstable/http/HttpServerError";
+import * as HttpServerRequest from "effect/unstable/http/HttpServerRequest";
+import * as HttpServerResponse from "effect/unstable/http/HttpServerResponse";
+import * as Socket from "effect/unstable/socket/Socket";
+import * as util from "node:util";
+import * as Http from "../../Http.ts";
+import { isWorkerEvent } from "./Worker.ts";
+
+export const workersHttpHandler = <Req = never>(
+  handler: Http.HttpEffect<Req>,
+) => {
+  const safeHandler = Http.safeHttpEffect(handler);
+  return (event: any) => {
+    if (isWorkerEvent(event) && event.type === "fetch") {
+      const webRequest = event.input;
+      return serveWebRequest(webRequest, safeHandler, {
+        remoteAddress: webRequest.headers.get("cf-connecting-ip") ?? undefined,
+      });
+    }
+  };
+};
+
+export const serveWebRequest = <Req = never>(
+  webRequest: cf.Request,
+  handler: Effect.Effect<
+    HttpServerResponse.HttpServerResponse,
+    HttpServerError.HttpServerError | HttpBodyError,
+    Req
+  >,
+  options: {
+    // Preserve transport metadata when this helper is adapting a request
+    // that originated from another runtime surface.
+    remoteAddress?: string;
+    // Durable Objects need to register the accepted socket on object state
+    // instead of calling `server.accept()` directly.
+    acceptWebSocket?: (socket: cf.WebSocket) => void;
+  } = {},
+): Effect.Effect<
+  Response,
+  never,
+  Exclude<Req, HttpServerRequest.HttpServerRequest | Scope>
+> =>
+  Effect.gen(function* () {
+    // `request.upgrade` and the eventual `101` response are two halves of the
+    // same operation, so we keep them in closure state shared by all modified
+    // views of this request.
+    let upgradedSocket: Socket.Socket | undefined;
+    let upgradeResponse: Response | undefined;
+    const make = (
+      base = HttpServerRequest.fromWeb(
+        webRequest as any as globalThis.Request,
+      ).modify({
+        remoteAddress: Option.fromUndefinedOr(options.remoteAddress),
+      }),
+    ): HttpServerRequest.HttpServerRequest => {
+      const request = Object.create(
+        base,
+      ) as HttpServerRequest.HttpServerRequest;
+
+      // Effect handlers are allowed to call `request.modify(...)`. We need those
+      // derived requests to preserve the same upgrade bookkeeping, otherwise a
+      // handler could upgrade one view of the request and return another.
+      Object.defineProperty(request, "modify", {
+        value: (
+          next: Parameters<HttpServerRequest.HttpServerRequest["modify"]>[0],
+        ) => make(base.modify(next)),
+      });
+
+      // The generic `fromWeb(...)` request cannot implement server-side
+      // websocket upgrade on its own, so Cloudflare injects the runtime-specific
+      // behavior here.
+      Object.defineProperty(request, "upgrade", {
+        get: () => {
+          if (upgradedSocket) {
+            return Effect.succeed(upgradedSocket);
+          }
+
+          if (
+            webRequest.method !== "GET" ||
+            webRequest.headers.get("upgrade")?.toLowerCase() !== "websocket"
+          ) {
+            return Effect.fail(
+              new HttpServerError.HttpServerError({
+                reason: new HttpServerError.RequestParseError({
+                  request,
+                  description: "Not an upgradeable ServerRequest",
+                }),
+              }),
+            );
+          }
+
+          const pair: [cf.WebSocket, cf.WebSocket] = new WebSocketPair();
+          const client = pair[0];
+          const server = pair[1];
+
+          if (options.acceptWebSocket) {
+            options.acceptWebSocket(server);
+          } else {
+            server.accept();
+          }
+
+          // Cloudflare completes the handshake by returning the client half in a
+          // `101` response, while Effect code continues talking to the server
+          // half through the `Socket` abstraction.
+          upgradeResponse = new Response(null, {
+            status: 101,
+            webSocket: client,
+          } as ResponseInit);
+          upgradedSocket = Effect.runSync(
+            Socket.fromWebSocket(
+              Effect.acquireRelease(
+                Effect.succeed(server as any as WebSocket),
+                (ws) => Effect.sync(() => ws.close(1000)),
+              ),
+            ),
+          );
+          return Effect.succeed(upgradedSocket);
+        },
+      });
+
+      return request;
+    };
+
+    const request = make();
+    const response = yield* handler.pipe(
+      Effect.provideService(HttpServerRequest.HttpServerRequest, request),
+      Effect.catchCause((cause) => {
+        console.error(
+          "[serveWebRequest] handler error:",
+          util.inspect(cause, { depth: null }),
+          typeof cause,
+        );
+        const message = Option.match(Cause.findErrorOption(cause), {
+          onNone: () => "Internal Server Error",
+          onSome: (error) =>
+            error instanceof Error && error.message
+              ? error.message
+              : "Internal Server Error",
+        });
+        return Effect.succeed(
+          HttpServerResponse.text(message, {
+            status: 500,
+            statusText: message,
+          }),
+        );
+      }),
+    );
+    // If the handler upgraded the request, the native handshake response must
+    // win over the ordinary Effect response conversion path.
+    if (upgradeResponse) return upgradeResponse;
+    const services = yield* Effect.services();
+    return HttpServerResponse.toWeb(response, { services });
+  }) as any;