alchemy 2.0.0-beta.47 → 2.0.0-beta.49

package/src/Cloudflare/BrowserRendering/BrowserRendering.ts

@@ -1,132 +0,0 @@
-import * as Effect from "effect/Effect";
-import { BrowserRenderingBinding } from "./BrowserRenderingBinding.ts";
-
-type BrowserRenderingTypeId = typeof BrowserRenderingTypeId;
-const BrowserRenderingTypeId = "Cloudflare.BrowserRendering" as const;
-
-export type BrowserRenderingProps = {
-  /**
-   * Binding name used when `Cloudflare.BrowserRendering.bind(browser)` attaches
-   * Browser Rendering from inside a Worker init phase. When Browser Rendering
-   * is passed through `Worker({ bindings: { ... } })`, the object key remains
-   * the binding name.
-   *
-   * @default "BROWSER"
-   */
-  name?: string;
-};
-
-/**
- * Marker for a Cloudflare Browser Rendering binding.
- *
- * Browser Rendering bindings are configured directly on Workers and do not
- * have a standalone provisioning API. The Worker provider sees this object in
- * `bindings: { ... }` and emits the corresponding `{ type: "browser" }`
- * metadata binding to the script.
- */
-export type BrowserRendering = {
-  kind: BrowserRenderingTypeId;
-  name: string;
-};
-
-export const isBrowserRendering = (value: unknown): value is BrowserRendering =>
-  typeof value === "object" &&
-  (value as BrowserRendering)?.kind === BrowserRenderingTypeId;
-
-/**
- * A Cloudflare Browser Rendering binding for launching headless browser
- * sessions from Workers via `@cloudflare/puppeteer`.
- *
- * @binding
- *
- * @section Effect-style Worker (recommended)
- * @example Render a page title with managed browser cleanup
- * ```typescript
- * import puppeteer from "@cloudflare/puppeteer";
- * import * as Effect from "effect/Effect";
- *
- * const Browser = Cloudflare.BrowserRendering({ name: "BROWSER" });
- *
- * Cloudflare.Worker(
- *   "BrowserWorker",
- *   { main: import.meta.filename },
- *   Effect.gen(function* () {
- *     const browserRendering = yield* Cloudflare.BrowserRendering.bind(
- *       yield* Browser,
- *     );
- *
- *     return {
- *       fetch: browserRendering.withBrowser(puppeteer, (browser) =>
- *         Effect.gen(function* () {
- *           const page = yield* Effect.tryPromise(() => browser.newPage());
- *           yield* Effect.tryPromise(() => page.goto("https://example.com"));
- *           const title = yield* Effect.tryPromise(() => page.title());
- *           return Response.json({ title });
- *         }),
- *       ),
- *     };
- *   }).pipe(Effect.provide(Cloudflare.BrowserRenderingBindingLive)),
- * );
- * ```
- *
- * @section Declaring Browser Rendering
- * @example
- * ```typescript
- * const Browser = yield* Cloudflare.BrowserRendering({ name: "BROWSER" });
- * ```
- *
- * @section Worker binding metadata
- * @example
- * ```typescript
- * export const Worker = Cloudflare.Worker("Worker", {
- *   main: "./src/worker.ts",
- *   bindings: {
- *     BROWSER: Cloudflare.BrowserRendering(),
- *   },
- * });
- *
- * export type WorkerEnv = Cloudflare.InferEnv<typeof Worker>;
- * //   { BROWSER: Fetcher }
- * ```
- *
- * @example Async-style worker with the raw runtime binding
- * ```typescript
- * import puppeteer from "@cloudflare/puppeteer";
- * import type { WorkerEnv } from "../alchemy.run.ts";
- *
- * export default {
- *   async fetch(request: Request, env: WorkerEnv) {
- *     const browser = await puppeteer.launch(env.BROWSER);
- *     const page = await browser.newPage();
- *     await page.goto("https://example.com");
- *     const screenshot = await page.screenshot();
- *     await browser.close();
- *
- *     return new Response(screenshot, {
- *       headers: { "content-type": "image/png" },
- *     });
- *   },
- * };
- * ```
- *
- * @see https://developers.cloudflare.com/browser-rendering/workers-binding-api/
- */
-export const BrowserRendering: {
-  (props?: BrowserRenderingProps): Effect.Effect<BrowserRendering>;
-  /**
-   * Bind Browser Rendering to the surrounding Worker, returning a small client
-   * with access to the native Workers runtime binding.
-   */
-  bind: typeof BrowserRenderingBinding.bind;
-} = Object.assign(
-  Effect.fn(function* (props?: BrowserRenderingProps) {
-    return {
-      kind: BrowserRenderingTypeId,
-      name: props?.name ?? "BROWSER",
-    } satisfies BrowserRendering;
-  }),
-  {
-    bind: (...args: Parameters<typeof BrowserRenderingBinding.bind>) =>
-      BrowserRenderingBinding.bind(...args),
-  },
-);

package/src/Cloudflare/BrowserRendering/BrowserRenderingBinding.ts

@@ -1,137 +0,0 @@
-import type * as cf from "@cloudflare/workers-types";
-import * as Data from "effect/Data";
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import * as Binding from "../../Binding.ts";
-import type { ResourceLike } from "../../Resource.ts";
-import { isWorker, WorkerEnvironment } from "../Workers/Worker.ts";
-import type { BrowserRendering as BrowserRenderingLike } from "./BrowserRendering.ts";
-
-export class BrowserRenderingError extends Data.TaggedError(
-  "BrowserRenderingError",
-)<{
-  message: string;
-  cause: unknown;
-}> {}
-
-export interface BrowserRenderingBrowser {
-  close(): Promise<void>;
-}
-
-export interface BrowserRenderingPuppeteer<
-  Browser extends BrowserRenderingBrowser,
-> {
-  launch(binding: cf.Fetcher): Promise<Browser>;
-}
-
-/**
- * Effect-native client for a Cloudflare Browser Rendering binding.
- *
- * Browser Rendering's Workers binding is consumed by `@cloudflare/puppeteer`.
- * Alchemy keeps Puppeteer as a caller-provided dependency while wrapping
- * launch and cleanup in Effects.
- */
-export interface BrowserRenderingClient {
-  /**
-   * Effect resolving to the raw Cloudflare Browser Rendering runtime binding.
-   */
-  raw: Effect.Effect<cf.Fetcher, never, WorkerEnvironment>;
-  /**
-   * Launch a Browser Rendering session through `@cloudflare/puppeteer`.
-   */
-  launch<Browser extends BrowserRenderingBrowser>(
-    puppeteer: BrowserRenderingPuppeteer<Browser>,
-  ): Effect.Effect<Browser, BrowserRenderingError, WorkerEnvironment>;
-  /**
-   * Launch a browser, run an Effect with it, and close it afterward.
-   */
-  withBrowser<Browser extends BrowserRenderingBrowser, A, E, R>(
-    puppeteer: BrowserRenderingPuppeteer<Browser>,
-    use: (browser: Browser) => Effect.Effect<A, E, R>,
-  ): Effect.Effect<A, BrowserRenderingError | E, WorkerEnvironment | R>;
-}
-
-export class BrowserRenderingBinding extends Binding.Service<
-  BrowserRenderingBinding,
-  (browser: BrowserRenderingLike) => Effect.Effect<BrowserRenderingClient>
->()("Cloudflare.BrowserRendering.Binding") {}
-
-export const BrowserRenderingBindingLive = Layer.effect(
-  BrowserRenderingBinding,
-  Effect.gen(function* () {
-    const Policy = yield* BrowserRenderingBindingPolicy;
-
-    return Effect.fn(function* (browser: BrowserRenderingLike) {
-      yield* Policy(browser);
-      // Cloudflare exposes Browser Rendering as a service-style binding for
-      // @cloudflare/puppeteer; workers-types has no narrower interface.
-      const raw = WorkerEnvironment.useSync(
-        (env) => (env as Record<string, cf.Fetcher>)[browser.name]!,
-      );
-      return makeBrowserRenderingClient(raw);
-    });
-  }),
-);
-
-export class BrowserRenderingBindingPolicy extends Binding.Policy<
-  BrowserRenderingBindingPolicy,
-  (browser: BrowserRenderingLike) => Effect.Effect<void>
->()("Cloudflare.BrowserRendering.Binding") {}
-
-export const BrowserRenderingBindingPolicyLive =
-  BrowserRenderingBindingPolicy.layer.succeed(
-    Effect.fn(function* (host: ResourceLike, browser: BrowserRenderingLike) {
-      if (isWorker(host)) {
-        yield* host.bind(browser.name, {
-          bindings: [
-            {
-              type: "browser",
-              name: browser.name,
-            },
-          ],
-        });
-      } else {
-        return yield* Effect.die(
-          new Error(
-            `BrowserRenderingBinding does not support runtime '${host.Type}'`,
-          ),
-        );
-      }
-    }),
-  );
-
-const tryPromise = <T>(
-  fn: () => Promise<T>,
-): Effect.Effect<T, BrowserRenderingError> =>
-  Effect.tryPromise({
-    try: fn,
-    catch: (error) =>
-      new BrowserRenderingError({
-        message:
-          error instanceof Error
-            ? error.message
-            : "Unknown Browser Rendering error",
-        cause: error,
-      }),
-  });
-
-/** @internal */
-export const makeBrowserRenderingClient = (
-  raw: Effect.Effect<cf.Fetcher, never, WorkerEnvironment>,
-): BrowserRenderingClient => {
-  const launch = <Browser extends BrowserRenderingBrowser>(
-    puppeteer: BrowserRenderingPuppeteer<Browser>,
-  ) =>
-    raw.pipe(
-      Effect.flatMap((binding) => tryPromise(() => puppeteer.launch(binding))),
-    );
-
-  return {
-    raw,
-    launch,
-    withBrowser: (puppeteer, use) =>
-      Effect.acquireUseRelease(launch(puppeteer), use, (browser) =>
-        tryPromise(() => browser.close()),
-      ),
-  } satisfies BrowserRenderingClient;
-};

package/src/Cloudflare/BrowserRendering/index.ts

@@ -1,11 +0,0 @@
-export * from "./BrowserRendering.ts";
-export {
-  BrowserRenderingBinding,
-  BrowserRenderingBindingLive,
-  BrowserRenderingBindingPolicy,
-  BrowserRenderingBindingPolicyLive,
-  BrowserRenderingError,
-  type BrowserRenderingBrowser,
-  type BrowserRenderingClient,
-  type BrowserRenderingPuppeteer,
-} from "./BrowserRenderingBinding.ts";