effect-cf 0.20.1 → 0.23.0

package/src/QueueBinding.ts

@@ -41,7 +41,7 @@ export interface QueueBindingClient<Message extends RpcDefinition.ServiceFreeSch
     options?: QueueSendBatchOptions,
   ) => Effect.Effect<void, QueueOperationError | S.SchemaError>;
   readonly metrics: () => Effect.Effect<QueueMetrics, QueueOperationError>;
-  readonly unsafeRaw: Effect.Effect<CloudflareQueue<S.Codec.Encoded<Message>>>;
+  readonly rawUnsafe: Effect.Effect<CloudflareQueue<S.Codec.Encoded<Message>>>;
 }
 
 export class QueueOperationError extends Data.TaggedError("QueueOperationError")<{
@@ -86,15 +86,16 @@ export const makeClient = <Message extends RpcDefinition.ServiceFreeSchema>(
   const encodeMessage = S.encodeEffect(definition.message);
 
   return (queue) => ({
-    send: Effect.fnUntraced(function* (message: Body, options?: QueueSendOptions) {
+    send: Effect.fn("QueueBinding.send", {
+      attributes: { binding: definition.binding, operation: "send" },
+    })(function* (message: Body, options?: QueueSendOptions) {
       const encoded = yield* encodeMessage(message);
 
       yield* tryQueuePromise(definition.binding, "send", () => queue.send(encoded, options));
     }),
-    sendBatch: Effect.fnUntraced(function* (
-      messages: Iterable<MessageSendRequest<Body>>,
-      options?: QueueSendBatchOptions,
-    ) {
+    sendBatch: Effect.fn("QueueBinding.sendBatch", {
+      attributes: { binding: definition.binding, operation: "sendBatch" },
+    })(function* (messages: Iterable<MessageSendRequest<Body>>, options?: QueueSendBatchOptions) {
       const encodedMessages: Array<MessageSendRequest<EncodedBody>> = [];
 
       for (const message of messages) {
@@ -106,22 +107,18 @@ export const makeClient = <Message extends RpcDefinition.ServiceFreeSchema>(
 
       const sendBatch = queue.sendBatch;
 
-      if (sendBatch !== undefined) {
-        yield* tryQueuePromise(definition.binding, "sendBatch", () =>
-          sendBatch.call(queue, encodedMessages, options),
-        );
-
-        return;
+      if (sendBatch === undefined) {
+        return yield* new QueueOperationError({
+          binding: definition.binding,
+          operation: "sendBatch",
+          cause: new Error(`Queue binding "${definition.binding}" does not provide sendBatch()`),
+          message: `Cloudflare queue binding "${definition.binding}" does not provide sendBatch()`,
+        });
       }
 
-      yield* tryQueuePromise(definition.binding, "sendBatch", async () => {
-        for (const message of encodedMessages) {
-          await queue.send(message.body, {
-            contentType: message.contentType,
-            delaySeconds: message.delaySeconds ?? options?.delaySeconds,
-          });
-        }
-      });
+      yield* tryQueuePromise(definition.binding, "sendBatch", () =>
+        sendBatch.call(queue, encodedMessages, options),
+      );
     }),
     metrics: () => {
       const metrics = queue.metrics;
@@ -139,7 +136,7 @@ export const makeClient = <Message extends RpcDefinition.ServiceFreeSchema>(
 
       return tryQueuePromise(definition.binding, "metrics", () => metrics.call(queue));
     },
-    unsafeRaw: Effect.succeed(queue as CloudflareQueue<EncodedBody>),
+    rawUnsafe: Effect.succeed(queue as CloudflareQueue<EncodedBody>),
   });
 };
 

package/src/QueueDefinition.ts

@@ -44,7 +44,11 @@ export interface TagClass<
   Self,
   Id extends string,
   Message extends RpcDefinition.ServiceFreeSchema,
-> extends Context.ServiceClass<Self, Id, QueueBinding.QueueBindingClient<Message>> {
+> extends Context.ServiceClass<
+  Self,
+  `effect-cf/Queue/${Id}`,
+  QueueBinding.QueueBindingClient<Message>
+> {
   readonly id: Id;
   readonly message: Message;
   readonly make: <ROut, LayerError>(
@@ -71,7 +75,7 @@ export interface TagClass<
     QueueBinding.QueueOperationError,
     Self
   >;
-  readonly unsafeRaw: () => Effect.Effect<globalThis.Queue<S.Codec.Encoded<Message>>, never, Self>;
+  readonly rawUnsafe: Effect.Effect<globalThis.Queue<S.Codec.Encoded<Message>>, never, Self>;
 }
 
 const makeDefinition = <Id extends string, Message extends RpcDefinition.ServiceFreeSchema>(
@@ -108,7 +112,9 @@ export const Tag =
     definition: { readonly message: Message },
   ) => {
     const queueDefinition = makeDefinition(id, definition);
-    const tag = Context.Service<Self, QueueBinding.QueueBindingClient<Message>>()(id);
+    const tag = Context.Service<Self, QueueBinding.QueueBindingClient<Message>>()(
+      `effect-cf/Queue/${id}` as const,
+    );
 
     const layer = (binding: LayerOptions) =>
       QueueBinding.layer(tag, {
@@ -140,11 +146,7 @@ export const Tag =
       return yield* queue.metrics();
     });
 
-    const unsafeRaw = Effect.fnUntraced(function* () {
-      const queue = yield* tag;
-
-      return yield* queue.unsafeRaw;
-    });
+    const rawUnsafe = Effect.flatMap(tag, (queue) => queue.rawUnsafe);
 
     return Object.assign(tag, {
       id: queueDefinition.id,
@@ -154,7 +156,7 @@ export const Tag =
       send,
       sendBatch,
       metrics,
-      unsafeRaw,
+      rawUnsafe,
     }) as TagClass<Self, Id, Message>;
   };
 
@@ -166,12 +168,11 @@ const wrapHandler = <ROut, const Self extends Definition.Any>(
 ): QueueEntrypoint.QueueHandler<ROut> => {
   const decodeBody = S.decodeUnknownEffect(definition.message);
 
-  return (batch) =>
-    Effect.gen(function* () {
-      const decoded = yield* QueueEntrypoint.decodeBatch(batch.raw, decodeBody);
+  return Effect.fnUntraced(function* (batch: QueueEntrypoint.QueueBatch<unknown>) {
+    const decoded = yield* QueueEntrypoint.decodeBatch(batch.raw, decodeBody);
 
-      yield* handler(decoded);
-    });
+    yield* handler(decoded);
+  });
 };
 
 export const implement = <ROut, const Self extends Definition.Any>(

package/src/R2.ts

@@ -16,16 +16,39 @@ import { Context, Data, Effect, Option, type Layer } from "effect";
 
 import * as Binding from "./Binding";
 import type { WorkerEnvironment } from "./Environment";
+import * as ErrorMessage from "./internal/ErrorMessage";
 
 const expectedR2Bucket =
   "R2 bucket binding with head(), get(), put(), createMultipartUpload(), resumeMultipartUpload(), delete(), and list()";
 
+/** R2 operation represented by {@link R2OperationError}. */
+export type R2Operation =
+  | "head"
+  | "get"
+  | "put"
+  | "delete"
+  | "list"
+  | "createMultipartUpload"
+  | "resumeMultipartUpload"
+  | "uploadPart"
+  | "abortMultipartUpload"
+  | "completeMultipartUpload"
+  | "arrayBuffer"
+  | "bytes"
+  | "text"
+  | "json"
+  | "blob";
+
 /** Error raised when an R2 operation fails. */
 export class R2OperationError extends Data.TaggedError("R2OperationError")<{
   readonly binding: string;
-  readonly operation: string;
+  readonly operation: R2Operation;
   readonly cause: unknown;
-}> {}
+}> {
+  override get message(): string {
+    return `R2 ${this.operation} failed for binding "${this.binding}": ${ErrorMessage.causeMessage(this.cause)}`;
+  }
+}
 
 /** Typed R2 bucket binding definition. */
 export interface R2Definition {
@@ -104,7 +127,7 @@ export interface R2Client {
   ) => Effect.Effect<R2MultipartUploadClient, R2OperationError>;
   readonly delete: (keys: string | ReadonlyArray<string>) => Effect.Effect<void, R2OperationError>;
   readonly list: (options?: R2ListOptions) => Effect.Effect<CloudflareR2Objects, R2OperationError>;
-  readonly unsafeRaw: Effect.Effect<CloudflareR2Bucket>;
+  readonly rawUnsafe: Effect.Effect<CloudflareR2Bucket>;
   readonly definition: R2Definition;
 }
 
@@ -136,12 +159,12 @@ export interface TagClass<Self, Id extends string> extends Context.ServiceClass<
   >;
 }
 
-const r2Error = (binding: string, operation: string, cause: unknown) =>
+const r2Error = (binding: string, operation: R2Operation, cause: unknown) =>
   new R2OperationError({ binding, operation, cause });
 
 const tryR2Promise = <A>(
   binding: string,
-  operation: string,
+  operation: R2Operation,
   evaluate: () => Promise<A>,
 ): Effect.Effect<A, R2OperationError> =>
   Effect.tryPromise({
@@ -151,7 +174,7 @@ const tryR2Promise = <A>(
 
 const tryR2Sync = <A>(
   binding: string,
-  operation: string,
+  operation: R2Operation,
   evaluate: () => A,
 ): Effect.Effect<A, R2OperationError> =>
   Effect.try({
@@ -159,8 +182,9 @@ const tryR2Sync = <A>(
     catch: (cause) => r2Error(binding, operation, cause),
   });
 
-const maybe = <A>(value: A | null): Option.Option<A> =>
-  value === null ? Option.none() : Option.some(value);
+const spanOptions = (binding: string, operation: R2Operation) => ({
+  attributes: { binding, operation },
+});
 
 const isR2ObjectBody = (
   value: CloudflareR2ObjectBody | CloudflareR2Object,
@@ -191,11 +215,22 @@ const wrapObjectBody = (binding: string, object: CloudflareR2ObjectBody): R2Obje
   get bodyUsed() {
     return object.bodyUsed;
   },
-  arrayBuffer: tryR2Promise(binding, "arrayBuffer", () => object.arrayBuffer()),
-  bytes: tryR2Promise(binding, "bytes", () => object.bytes()),
-  text: tryR2Promise(binding, "text", () => object.text()),
-  json: <T = unknown>() => tryR2Promise(binding, "json", () => object.json<T>()),
-  blob: tryR2Promise(binding, "blob", () => object.blob()),
+  arrayBuffer: tryR2Promise(binding, "arrayBuffer", () => object.arrayBuffer()).pipe(
+    Effect.withSpan("R2.arrayBuffer", spanOptions(binding, "arrayBuffer")),
+  ),
+  bytes: tryR2Promise(binding, "bytes", () => object.bytes()).pipe(
+    Effect.withSpan("R2.bytes", spanOptions(binding, "bytes")),
+  ),
+  text: tryR2Promise(binding, "text", () => object.text()).pipe(
+    Effect.withSpan("R2.text", spanOptions(binding, "text")),
+  ),
+  json: <T = unknown>() =>
+    tryR2Promise(binding, "json", () => object.json<T>()).pipe(
+      Effect.withSpan("R2.json", spanOptions(binding, "json")),
+    ),
+  blob: tryR2Promise(binding, "blob", () => object.blob()).pipe(
+    Effect.withSpan("R2.blob", spanOptions(binding, "blob")),
+  ),
 });
 
 const wrapGetResult = (
@@ -234,29 +269,55 @@ export const makeClient = (
     raw: upload,
     key: upload.key,
     uploadId: upload.uploadId,
-    uploadPart: (partNumber, value, options) =>
+    uploadPart: Effect.fn(
+      "R2.uploadPart",
+      spanOptions(definition.binding, "uploadPart"),
+    )((partNumber: number, value: R2UploadPartValue, options?: R2UploadPartOptions) =>
       tryR2Promise(definition.binding, "uploadPart", () =>
         upload.uploadPart(partNumber, value, options),
       ),
-    abort: tryR2Promise(definition.binding, "abortMultipartUpload", () => upload.abort()),
-    complete: (uploadedParts) =>
+    ),
+    abort: tryR2Promise(definition.binding, "abortMultipartUpload", () => upload.abort()).pipe(
+      Effect.withSpan(
+        "R2.abortMultipartUpload",
+        spanOptions(definition.binding, "abortMultipartUpload"),
+      ),
+    ),
+    complete: Effect.fn(
+      "R2.completeMultipartUpload",
+      spanOptions(definition.binding, "completeMultipartUpload"),
+    )((uploadedParts: ReadonlyArray<CloudflareR2UploadedPart>) =>
       tryR2Promise(definition.binding, "completeMultipartUpload", () =>
         upload.complete([...uploadedParts]),
       ),
+    ),
   });
 
   return (bucket) => {
-    const get = ((key: string, options?: R2GetOptions) =>
+    const get = Effect.fn(
+      "R2.get",
+      spanOptions(definition.binding, "get"),
+    )((key: string, options?: R2GetOptions) =>
       tryR2Promise(definition.binding, "get", () => bucket.get(key, options)).pipe(
-        Effect.map((object) => maybe(wrapGetResult(definition.binding, object))),
-      )) as R2Client["get"];
+        Effect.map((object) => Option.fromNullOr(wrapGetResult(definition.binding, object))),
+      ),
+    ) as R2Client["get"];
 
     return {
       definition,
-      head: (key) =>
-        tryR2Promise(definition.binding, "head", () => bucket.head(key)).pipe(Effect.map(maybe)),
+      head: Effect.fn(
+        "R2.head",
+        spanOptions(definition.binding, "head"),
+      )((key: string) =>
+        tryR2Promise(definition.binding, "head", () => bucket.head(key)).pipe(
+          Effect.map(Option.fromNullOr),
+        ),
+      ),
       get,
-      put: ((key: string, value: R2PutValue, options?: R2PutOptions) =>
+      put: Effect.fn(
+        "R2.put",
+        spanOptions(definition.binding, "put"),
+      )((key: string, value: R2PutValue, options?: R2PutOptions) =>
         tryR2Promise(definition.binding, "put", () => bucket.put(key, value, options)).pipe(
           Effect.map((object) => {
             if (object === null) {
@@ -269,22 +330,39 @@ export const makeClient = (
 
             return object;
           }),
-        )) as R2Client["put"],
-      createMultipartUpload: (key, options) =>
+        ),
+      ) as R2Client["put"],
+      createMultipartUpload: Effect.fn(
+        "R2.createMultipartUpload",
+        spanOptions(definition.binding, "createMultipartUpload"),
+      )((key: string, options?: R2MultipartOptions) =>
         tryR2Promise(definition.binding, "createMultipartUpload", () =>
           bucket.createMultipartUpload(key, options),
         ).pipe(Effect.map(wrapUpload)),
-      resumeMultipartUpload: (key, uploadId) =>
+      ),
+      resumeMultipartUpload: Effect.fn(
+        "R2.resumeMultipartUpload",
+        spanOptions(definition.binding, "resumeMultipartUpload"),
+      )((key: string, uploadId: string) =>
         tryR2Sync(definition.binding, "resumeMultipartUpload", () =>
           wrapUpload(bucket.resumeMultipartUpload(key, uploadId)),
         ),
-      delete: (keys) => {
+      ),
+      delete: Effect.fn(
+        "R2.delete",
+        spanOptions(definition.binding, "delete"),
+      )((keys: string | ReadonlyArray<string>) => {
         const nativeKeys = typeof keys === "string" ? keys : [...keys];
 
         return tryR2Promise(definition.binding, "delete", () => bucket.delete(nativeKeys));
-      },
-      list: (options) => tryR2Promise(definition.binding, "list", () => bucket.list(options)),
-      unsafeRaw: Effect.succeed(bucket),
+      }),
+      list: Effect.fn(
+        "R2.list",
+        spanOptions(definition.binding, "list"),
+      )((options?: R2ListOptions) =>
+        tryR2Promise(definition.binding, "list", () => bucket.list(options)),
+      ),
+      rawUnsafe: Effect.succeed(bucket),
     };
   };
 };

package/src/Rpc.ts

@@ -1,6 +1,8 @@
 import { RpcStub, RpcTarget } from "cloudflare:workers";
 import { Effect, type Scope } from "effect";
 
+import { decodeWireError } from "./RpcDefinition";
+
 export { RpcStub, RpcTarget };
 
 export type Stubable = Rpc.Stubable;
@@ -113,7 +115,7 @@ export const resolve = <A>(value: A): Effect.Effect<Awaited<A>, unknown> =>
   isPromiseLike(value)
     ? Effect.tryPromise({
         try: () => value,
-        catch: (cause) => cause,
+        catch: (cause) => decodeWireError(cause),
       })
     : Effect.sync(() => value as Awaited<A>);