import * as r2 from "@distilled.cloud/cloudflare/r2";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as Stream from "effect/Stream";
import { authorizeWith } from "../HttpClientUtils.ts";
import {
baseObject,
makeHttpBucketBinding,
makeR2HttpScope,
toR2Error,
type HttpMetadata,
type R2Auth,
} from "./BucketHttp.ts";
import { R2Error, type GetOptions, type ListOptions, type Objects } from "./BucketTypes.ts";
import { ReadBucket, type ReadBucketClient } from "./ReadBucket.ts";
/**
* HTTP-backed implementation of the {@link ReadBucket} binding.
*
* It creates a scoped {@link AccountApiToken} with the `Workers R2 Storage Read` and `Workers R2 Storage Write` permissions.
*/
export const ReadBucketHttp = Layer.effect(
ReadBucket,
Effect.suspend(() =>
makeHttpBucketBinding({
permissionGroups: ["Workers R2 Storage Read"],
makeClient: (token, bucketName, jurisdiction) =>
makeReadR2HttpClient(
{ authorize: authorizeWith(token), accountId: token.accountId },
bucketName,
jurisdiction,
),
}),
),
);
export const makeReadR2HttpClient = (
auth: R2Auth,
bucketName: Effect.Effect<string>,
jurisdiction: Effect.Effect<string>,
): ReadBucketClient => {
const authorize = auth.authorize;
const scope = makeR2HttpScope(auth.accountId, bucketName, jurisdiction);
return {
raw: Effect.die(
new R2Error({
message:
"R2BucketBindingHttp does not expose a native `raw` Bucket; use the binary HTTP methods instead.",
cause: new Error("unsupported"),
}),
),
head: (key: string) =>
scope.pipe(
Effect.flatMap(({ accountId, bucketName, cfR2Jurisdiction }) =>
authorize(
r2.getObject({
accountId,
bucketName,
objectName: key,
cfR2Jurisdiction,
}),
),
),
// The HTTP body is lazy, so reading headers does not download it.
Effect.map((res) =>
baseObject(key, httpMetadataOf(res), {
size: res.contentLength,
etag: res.etag,
uploaded: res.lastModified ? new Date(res.lastModified) : undefined,
storageClass: res.cfR2StorageClass,
}),
),
// Native R2 `head` resolves to `null` for a missing object rather
// than failing — mirror that for the HTTP-backed client.
Effect.catchTag("NoSuchKey", () => Effect.succeed(null)),
Effect.mapError(toR2Error),
),
get: ((key: string, _options?: GetOptions) =>
scope.pipe(
Effect.flatMap(({ accountId, bucketName, cfR2Jurisdiction }) =>
authorize(
r2.getObject({
accountId,
bucketName,
objectName: key,
cfR2Jurisdiction,
}),
),
),
Effect.map((res) => objectBodyFromResponse(key, res)),
// Native R2 `get` resolves to `null` for a missing object.
Effect.catchTag("NoSuchKey", () => Effect.succeed(null)),
Effect.mapError(toR2Error),
)) as any,
list: (options?: ListOptions) =>
scope.pipe(
Effect.flatMap(({ accountId, bucketName, cfR2Jurisdiction }) =>
authorize(
r2.listObjects({
accountId,
bucketName,
cfR2Jurisdiction,
prefix: options?.prefix,
delimiter: options?.delimiter,
cursor: options?.cursor,
startAfter: options?.startAfter,
perPage: options?.limit,
}),
),
),
Effect.mapError(toR2Error),
Effect.map((res) => {
const objects = res.result.map((o) =>
baseObject(
o.key ?? "",
{},
{
size: o.size ?? undefined,
etag: o.etag ?? undefined,
uploaded: o.lastModified ? new Date(o.lastModified) : undefined,
storageClass: o.storageClass ?? undefined,
customMetadata: (o.customMetadata as Record<string, string> | null) ?? undefined,
},
),
);
const cursor = res.resultInfo?.cursor ?? undefined;
return (
cursor
? { objects, delimitedPrefixes: [], truncated: true, cursor }
: { objects, delimitedPrefixes: [], truncated: false }
) as Objects;
}),
),
};
};
const objectBodyFromResponse = (key: string, res: r2.GetObjectResponse): R2ObjectBody => {
const meta = httpMetadataOf(res);
// The HTTP body is a single-consumption stream — expose it both as a Stream
// and via the buffering accessors, but the caller may only read it once.
let response: Response | undefined;
const getResponse = () => (response ??= new Response(Stream.toReadableStream(res.body) as any));
const consume = <T>(fn: (r: Response) => Promise<T>): Effect.Effect<T, R2Error> =>
Effect.tryPromise({ try: () => fn(getResponse()), catch: toR2Error });
return {
...baseObject(key, meta, {
size: res.contentLength,
etag: res.etag,
uploaded: res.lastModified ? new Date(res.lastModified) : undefined,
storageClass: res.cfR2StorageClass,
}),
body: Stream.fromReadableStream({
evaluate: () => getResponse().body as ReadableStream<Uint8Array>,
onError: toR2Error,
}),
bodyUsed: false,
arrayBuffer: () => consume((r) => r.arrayBuffer()),
bytes: () => consume((r) => r.arrayBuffer().then((b) => new Uint8Array(b))),
text: () => consume((r) => r.text()),
json: <T>() => consume((r) => r.json() as Promise<T>),
blob: () => consume((r) => r.blob()),
} as unknown as R2ObjectBody;
};
const httpMetadataOf = (res: r2.GetObjectResponse): HttpMetadata => ({
contentType: res.contentType,
contentEncoding: res.contentEncoding,
contentDisposition: res.contentDisposition,
contentLanguage: res.contentLanguage,
cacheControl: res.cacheControl,
cacheExpiry: res.expires ? new Date(res.expires) : undefined,
});