import type * as cf from "@cloudflare/workers-types";
import * as Effect from "effect/Effect";
import * as Stream from "effect/Stream";
import * as Binding from "../Workers/Binding.ts";
import { makeBindingLayer } from "../Workers/BindingLayer.ts";
import {
Images,
ImagesError,
type ImagesClient,
type ImageTransformationResult,
type ImageTransformer,
} from "./Images.ts";
/** The binding value produced by calling {@link Images} (declared on `env` or `yield*`-ed). */
export type ImagesBinding = Binding.Binding<Images["key"], ImagesClient, Images>;
/**
* The layer that provides the Effect-native interface for the Cloudflare
* Workers Images binding.
*
* Provide it on the Worker effect (`Effect.provide(Cloudflare.Images.ImagesBinding)`)
* so that yielding an {@link Images} binding attaches the native `images`
* binding to the surrounding Worker at deploy time and, at runtime, resolves to
* the Effect-native {@link ImagesClient} (wrapping the raw `cf.ImagesBinding` so every
* `info` / `input(...).transform(...).output(...)` call returns an `Effect`).
*/
export const ImagesBinding = makeBindingLayer<Images, cf.ImagesBinding, ImagesClient>(
Images,
(raw) =>
({
raw,
info: (stream, options) =>
Effect.gen(function* () {
const binding = yield* raw;
const readable = yield* toCfReadable(stream);
return yield* tryPromise(() => binding.info(readable, options));
}),
input: (stream, options) =>
Effect.gen(function* () {
const binding = yield* raw;
const readable = yield* toCfReadable(stream);
return wrapTransformer(binding.input(readable, options));
}),
}) satisfies ImagesClient,
);
/**
* Wrap a runtime `ImageTransformer` as the Effect-native chainable client.
* `transform`/`draw` stay pure; `output` crosses into the runtime.
*/
const wrapTransformer = (raw: cf.ImageTransformer): ImageTransformer => ({
raw,
transform: (transform) => wrapTransformer(raw.transform(transform)),
draw: <E, R>(
image: Stream.Stream<Uint8Array, E, R> | ImageTransformer,
options?: cf.ImageDrawOptions,
): Effect.Effect<ImageTransformer, never, R> => {
if (isTransformerClient(image)) {
return Effect.succeed(wrapTransformer(raw.draw(image.raw, options)));
}
return toCfReadable(image).pipe(
Effect.map((readable) => wrapTransformer(raw.draw(readable, options))),
);
},
output: (options) => tryPromise(() => raw.output(options)).pipe(Effect.map(wrapResult)),
});
/** Wrap a runtime `ImageTransformationResult` as the Effect-native result client. */
const wrapResult = (raw: cf.ImageTransformationResult): ImageTransformationResult => ({
raw,
response: Effect.sync(() => raw.response()),
contentType: Effect.sync(() => raw.contentType()),
image: (options) => Effect.sync(() => raw.image(options)),
});
/**
* Convert an Effect `Stream<Uint8Array>` into the `cf.ReadableStream<Uint8Array>`
* shape the Images runtime binding expects (identical at runtime).
*/
const toCfReadable = <E, R>(
stream: Stream.Stream<Uint8Array, E, R>,
): Effect.Effect<cf.ReadableStream<Uint8Array>, never, R> =>
Stream.toReadableStreamEffect(stream).pipe(
Effect.map((s) => s as unknown as cf.ReadableStream<Uint8Array>),
);
const tryPromise = <T>(fn: () => Promise<T>): Effect.Effect<T, ImagesError> =>
Effect.tryPromise({
try: fn,
catch: (error: any) =>
new ImagesError({
message: error?.message ?? "Unknown error",
code: typeof error?.code === "number" ? error.code : undefined,
cause: error,
}),
});
const isTransformerClient = (image: unknown): image is ImageTransformer =>
typeof image === "object" && image !== null && "raw" in image;