sailfork / t3code-github / .repos/ alchemy-effect/ packages/ cloudflare/ src/ Workers/ BrowserBinding.ts

import type * as cf from "@cloudflare/workers-types";
import type { RuntimeContext } from "alchemy/RuntimeContext";
import * as Effect from "effect/Effect";
import * as Stream from "effect/Stream";
import * as Binding from "./Binding.ts";
import { makeBindingLayer } from "./BindingLayer.ts";
import { Browser, type BrowserClient, BrowserError, type BrowserResponse } from "./Browser.ts";

/** The binding value produced by calling {@link Browser} (declared on `env` or `yield*`-ed). */
export type BrowserBinding = Binding.Binding<Browser["key"], BrowserClient, Browser>;

/**
 * The layer that provides the Effect-native interface for the Cloudflare
 * Workers Browser Rendering binding.
 *
 * Provide it on the Worker effect (`Effect.provide(Cloudflare.Workers.BrowserBinding)`)
 * so that yielding a {@link Browser} binding attaches the native `browser`
 * binding to the surrounding Worker at deploy time and, at runtime, resolves to
 * the Effect-native {@link BrowserClient}.
 */
export const BrowserBinding = makeBindingLayer<Browser, cf.BrowserRun, BrowserClient>(
  Browser,
  (raw): BrowserClient => {
    const respond = (
      action: string,
      options: unknown,
    ): Effect.Effect<BrowserResponse, BrowserError, RuntimeContext> =>
      raw.pipe(
        Effect.flatMap((binding) =>
          tryPromise(() => binding.quickAction(action as any, options as any)),
        ),
        Effect.flatMap((response) =>
          response.ok ? Effect.succeed(response) : failResponse(action, response),
        ),
      );

    const jsonAction = <T>(
      action: string,
      options: unknown,
    ): Effect.Effect<T, BrowserError, RuntimeContext> =>
      respond(action, options).pipe(
        Effect.flatMap((response) => tryPromise(() => response.json() as Promise<T>)),
      );

    const streamAction = (
      action: string,
      options: unknown,
    ): Stream.Stream<Uint8Array, BrowserError, RuntimeContext> =>
      respond(action, options).pipe(
        Effect.map((response) =>
          Stream.fromReadableStream({
            evaluate: () => response.body as any as ReadableStream<Uint8Array<ArrayBufferLike>>,
            onError: (cause) =>
              new BrowserError({
                message: `Browser Rendering '${action}' stream failed`,
                cause,
              }),
          }),
        ),
        Stream.unwrap,
      );

    const quickAction = ((action: string, options: unknown) =>
      BINARY_ACTIONS.has(action)
        ? streamAction(action, options)
        : jsonAction(action, options)) as BrowserClient["quickAction"];

    return {
      raw,
      fetch: (...args) =>
        raw.pipe(Effect.flatMap((binding) => tryPromise(() => binding.fetch(...args)))),
      quickAction,
      screenshot: (options) => streamAction("screenshot", options),
      pdf: (options) => streamAction("pdf", options),
      content: (options) => jsonAction("content", options),
      scrape: (options) => jsonAction("scrape", options),
      links: (options) => jsonAction("links", options),
      snapshot: (options) => jsonAction("snapshot", options),
      json: (options) => jsonAction("json", options),
      markdown: (options) => jsonAction("markdown", options),
    } satisfies BrowserClient;
  },
);

/** Actions whose successful response is raw binary rather than JSON. */
const BINARY_ACTIONS = new Set(["screenshot", "pdf"]);

/** Build a {@link BrowserError} from a non-success Browser Run response. */
const failResponse = (
  action: string,
  response: BrowserResponse,
): Effect.Effect<never, BrowserError> =>
  tryPromise(() => response.text()).pipe(
    Effect.flatMap((body) => {
      let cause: unknown = body;
      try {
        cause = JSON.parse(body);
      } catch {
        // keep the raw text as the cause
      }
      const message =
        (cause as cf.BrowserRunErrorResponse | undefined)?.errors?.[0]?.message ??
        `Browser Rendering '${action}' failed with status ${response.status}`;
      return Effect.fail(new BrowserError({ message, cause }));
    }),
  );

const tryPromise = <T>(fn: () => Promise<T>): Effect.Effect<T, BrowserError> =>
  Effect.tryPromise({
    try: fn,
    catch: (error) =>
      new BrowserError({
        message: error instanceof Error ? error.message : "Unknown Browser Rendering error",
        cause: error,
      }),
  });