effect-cf 0.20.1 → 0.23.0

package/src/ServiceBinding.ts

@@ -4,6 +4,7 @@ import * as Binding from "./Binding";
 import * as CloudflareRpc from "./Rpc";
 import * as RpcDefinition from "./RpcDefinition";
 import type * as WorkerDefinition from "./WorkerDefinition";
+import * as ErrorMessage from "./internal/ErrorMessage";
 import * as RpcInvocation from "./internal/RpcInvocation";
 
 const TypeId = "effect-cf/ServiceBinding" as const;
@@ -58,7 +59,11 @@ export interface ServiceBindingDefinition<
 export class ServiceBindingFetchError extends Data.TaggedError("ServiceBindingFetchError")<{
   readonly binding: string;
   readonly cause: unknown;
-}> {}
+}> {
+  override get message(): string {
+    return `Service binding "${this.binding}" fetch failed: ${ErrorMessage.causeMessage(this.cause)}`;
+  }
+}
 
 /**
  * Failure raised when invoking an RPC method on a service binding.
@@ -67,7 +72,11 @@ export class ServiceBindingRpcError extends Data.TaggedError("ServiceBindingRpcE
   readonly binding: string;
   readonly method: string;
   readonly cause: unknown;
-}> {}
+}> {
+  override get message(): string {
+    return `Service binding "${this.binding}" RPC method "${this.method}" failed: ${ErrorMessage.causeMessage(this.cause)}`;
+  }
+}
 
 type ServiceMethodKey<Api> = RpcInvocation.AsyncMethodKey<Api>;
 type ServiceMethodArgs<Api, Method extends keyof Api> = RpcInvocation.AsyncMethodArgs<Api, Method>;
@@ -235,107 +244,106 @@ export const makeClient = <
   definition: ServiceBindingDefinition<Definition>,
 ): ((service: ServiceBindingClient<Api>) => ServiceBindingEffectClient<Api, Definition>) => {
   return (service: ServiceBindingClient<Api>) => {
-    const fetch = (input: RequestInfo | URL, init?: RequestInit) =>
-      Effect.tryPromise({
+    const fetch = Effect.fn("ServiceBinding.fetch")(function* (
+      input: RequestInfo | URL,
+      init?: RequestInit,
+    ) {
+      return yield* Effect.tryPromise({
         try: () => service.fetch(input, init),
         catch: (cause) => new ServiceBindingFetchError({ binding: definition.binding, cause }),
       });
+    });
 
-    const rpc = <Method extends ServiceMethodKey<Api>>(
+    const rpc = Effect.fn("ServiceBinding.rpc")(function* <Method extends ServiceMethodKey<Api>>(
       method: Method,
       ...args: ServiceMethodArgs<Api, Method>
-    ) =>
-      Effect.gen(function* () {
-        const methodName = String(method);
-        const encodedArgs =
-          definition.definition === undefined
-            ? args
-            : yield* RpcDefinition.encodeArgs(
-                definition.definition,
-                methodName as RpcDefinition.Definition.MethodNames<NonNullable<Definition>>,
-                args as never,
-              ).pipe(
-                Effect.mapError(
-                  (cause) =>
-                    new ServiceBindingRpcError({
-                      binding: definition.binding,
-                      method: methodName,
-                      cause,
-                    }),
-                ),
-              );
-
-        return yield* RpcInvocation.invokeRpcMethod(
-          service,
-          method,
-          encodedArgs as ServiceMethodArgs<Api, Method>,
+    ) {
+      const methodName = String(method);
+      const encodedArgs =
+        definition.definition === undefined
+          ? args
+          : yield* RpcDefinition.encodeArgs(
+              definition.definition,
+              methodName as RpcDefinition.Definition.MethodNames<NonNullable<Definition>>,
+              args as never,
+            ).pipe(
+              Effect.mapError(
+                (cause) =>
+                  new ServiceBindingRpcError({
+                    binding: definition.binding,
+                    method: methodName,
+                    cause,
+                  }),
+              ),
+            );
+
+      return yield* RpcInvocation.invokeRpcMethod(
+        service,
+        method,
+        encodedArgs as ServiceMethodArgs<Api, Method>,
+        (cause) =>
+          new ServiceBindingRpcError({
+            binding: definition.binding,
+            method: methodName,
+            cause,
+          }),
+      );
+    });
+
+    const decodeSuccess = Effect.fnUntraced(function* <Method extends ServiceMethodKey<Api>>(
+      methodName: string,
+      value: Awaited<ServiceMethodCloudflareReturn<Api, Method>>,
+    ) {
+      if (definition.definition === undefined) {
+        return value as ServiceMethodSuccess<Api, Method>;
+      }
+
+      const decoded = yield* RpcDefinition.decodeSuccess(
+        definition.definition,
+        methodName as RpcDefinition.Definition.MethodNames<NonNullable<Definition>>,
+        value,
+      ).pipe(
+        Effect.mapError(
           (cause) =>
             new ServiceBindingRpcError({
               binding: definition.binding,
               method: methodName,
               cause,
             }),
-        );
-      });
+        ),
+      );
 
-    const decodeSuccess = <Method extends ServiceMethodKey<Api>>(
-      methodName: string,
-      value: Awaited<ServiceMethodCloudflareReturn<Api, Method>>,
-    ) =>
-      Effect.gen(function* () {
-        if (definition.definition === undefined) {
-          return value as ServiceMethodSuccess<Api, Method>;
-        }
-
-        const decoded = yield* RpcDefinition.decodeSuccess(
-          definition.definition,
-          methodName as RpcDefinition.Definition.MethodNames<NonNullable<Definition>>,
-          value,
-        ).pipe(
-          Effect.mapError(
-            (cause) =>
-              new ServiceBindingRpcError({
-                binding: definition.binding,
-                method: methodName,
-                cause,
-              }),
-          ),
-        );
-
-        return decoded as ServiceMethodSuccess<Api, Method>;
-      });
+      return decoded as ServiceMethodSuccess<Api, Method>;
+    });
 
-    const call = <Method extends ServiceMethodKey<Api>>(
+    const call = Effect.fn("ServiceBinding.call")(function* <Method extends ServiceMethodKey<Api>>(
       method: Method,
       ...args: ServiceMethodArgs<Api, Method>
-    ) =>
-      Effect.gen(function* () {
-        const methodName = String(method);
-        const value = yield* CloudflareRpc.resolve(yield* rpc(method, ...args)).pipe(
-          Effect.mapError(
-            (cause) =>
-              new ServiceBindingRpcError({
-                binding: definition.binding,
-                method: methodName,
-                cause,
-              }),
-          ),
-        );
-
-        return yield* decodeSuccess<Method>(methodName, value);
-      });
+    ) {
+      const methodName = String(method);
+      const value = yield* CloudflareRpc.resolve(yield* rpc(method, ...args)).pipe(
+        Effect.mapError(
+          (cause) =>
+            new ServiceBindingRpcError({
+              binding: definition.binding,
+              method: methodName,
+              cause,
+            }),
+        ),
+      );
 
-    const scopedCall = <Method extends ServiceMethodKey<Api>>(
-      method: Method,
-      ...args: ServiceMethodArgs<Api, Method>
-    ) =>
-      Effect.gen(function* () {
-        const methodName = String(method);
-        const result = yield* rpc(method, ...args);
-        const value = yield* CloudflareRpc.scoped(result);
+      return yield* decodeSuccess<Method>(methodName, value);
+    });
 
-        return yield* decodeSuccess<Method>(methodName, value);
-      });
+    const scopedCall = Effect.fn("ServiceBinding.scopedCall")(function* <
+      Method extends ServiceMethodKey<Api>,
+    >(method: Method, ...args: ServiceMethodArgs<Api, Method>) {
+      const methodName = String(method);
+      const result = yield* rpc(method, ...args);
+      const value = yield* CloudflareRpc.scoped(result);
+
+      return yield* decodeSuccess<Method>(methodName, value);
+    });
 
     const directMethods = makeDirectMethods<never, Api, Definition>(definition.definition, call);
 
@@ -411,42 +419,38 @@ export const Service =
       makeClient<ServiceApi, Definition>(definition),
     );
 
-    const fetch = (input: RequestInfo | URL, init?: RequestInit) =>
-      Effect.gen(function* () {
-        const service = yield* tag;
+    const fetch = Effect.fnUntraced(function* (input: RequestInfo | URL, init?: RequestInit) {
+      const service = yield* tag;
 
-        return yield* service.fetch(input, init);
-      });
+      return yield* service.fetch(input, init);
+    });
 
-    const rpc = <Method extends ServiceMethodKey<ServiceApi>>(
+    const rpc = Effect.fnUntraced(function* <Method extends ServiceMethodKey<ServiceApi>>(
       method: Method,
       ...args: ServiceMethodArgs<ServiceApi, Method>
-    ) =>
-      Effect.gen(function* () {
-        const service = yield* tag;
+    ) {
+      const service = yield* tag;
 
-        return yield* service.rpc(method, ...args);
-      });
+      return yield* service.rpc(method, ...args);
+    });
 
-    const call = <Method extends ServiceMethodKey<ServiceApi>>(
+    const call = Effect.fnUntraced(function* <Method extends ServiceMethodKey<ServiceApi>>(
       method: Method,
       ...args: ServiceMethodArgs<ServiceApi, Method>
-    ) =>
-      Effect.gen(function* () {
-        const service = yield* tag;
+    ) {
+      const service = yield* tag;
 
-        return yield* service.call(method, ...args);
-      });
+      return yield* service.call(method, ...args);
+    });
 
-    const scopedCall = <Method extends ServiceMethodKey<ServiceApi>>(
+    const scopedCall = Effect.fnUntraced(function* <Method extends ServiceMethodKey<ServiceApi>>(
       method: Method,
       ...args: ServiceMethodArgs<ServiceApi, Method>
-    ) =>
-      Effect.gen(function* () {
-        const service = yield* tag;
+    ) {
+      const service = yield* tag;
 
-        return yield* service.scopedCall(method, ...args);
-      });
+      return yield* service.scopedCall(method, ...args);
+    });
 
     const directMethods = makeDirectMethods<Self, ServiceApi, Definition>(
       definition.definition,

package/src/Vectorize.ts

@@ -17,16 +17,31 @@ import type {
 
 import * as Binding from "./Binding";
 import type { WorkerEnvironment } from "./Environment";
+import * as ErrorMessage from "./internal/ErrorMessage";
 
 const expectedVectorizeBinding =
   "Vectorize index binding with describe(), query(), insert(), upsert(), deleteByIds(), and getByIds()";
 
+/** Vectorize operation represented by {@link VectorizeOperationError}. */
+export type VectorizeOperation =
+  | "describe"
+  | "query"
+  | "queryById"
+  | "insert"
+  | "upsert"
+  | "deleteByIds"
+  | "getByIds";
+
 /** Error raised when a Vectorize operation fails. */
 export class VectorizeOperationError extends Data.TaggedError("VectorizeOperationError")<{
   readonly binding: string;
-  readonly operation: string;
+  readonly operation: VectorizeOperation;
   readonly cause: unknown;
-}> {}
+}> {
+  override get message(): string {
+    return `Vectorize ${this.operation} failed for binding "${this.binding}": ${ErrorMessage.causeMessage(this.cause)}`;
+  }
+}
 
 /** Typed Vectorize binding definition. */
 export interface VectorizeDefinition {
@@ -93,7 +108,7 @@ export interface VectorizeClient {
   readonly getByIds: (
     ids: ReadonlyArray<string>,
   ) => Effect.Effect<ReadonlyArray<VectorizeVector>, VectorizeOperationError>;
-  readonly unsafeRaw: Effect.Effect<VectorizeBinding>;
+  readonly rawUnsafe: Effect.Effect<VectorizeBinding>;
   readonly definition: VectorizeDefinition;
 }
 
@@ -125,12 +140,12 @@ export interface TagClass<Self, Id extends string> extends Context.ServiceClass<
   >;
 }
 
-const vectorizeError = (binding: string, operation: string, cause: unknown) =>
+const vectorizeError = (binding: string, operation: VectorizeOperation, cause: unknown) =>
   new VectorizeOperationError({ binding, operation, cause });
 
 const tryVectorizePromise = <A>(
   binding: string,
-  operation: string,
+  operation: VectorizeOperation,
   evaluate: () => Promise<A>,
 ): Effect.Effect<A, VectorizeOperationError> =>
   Effect.tryPromise({
@@ -138,6 +153,10 @@ const tryVectorizePromise = <A>(
     catch: (cause) => vectorizeError(binding, operation, cause),
   });
 
+const spanOptions = (binding: string, operation: VectorizeOperation) => ({
+  attributes: { binding, operation },
+});
+
 const hasFunction = (value: object, key: string): boolean =>
   typeof Reflect.get(value, key) === "function";
 
@@ -155,17 +174,30 @@ export const makeClient =
   (definition: VectorizeDefinition) =>
   (index: VectorizeBinding): VectorizeClient => {
     const runtime = index as VectorizeRuntimeBinding;
-    const deleteByIds = (ids: ReadonlyArray<string>) =>
-      tryVectorizePromise(definition.binding, "deleteByIds", () => runtime.deleteByIds([...ids]));
+    const deleteByIds = Effect.fn(
+      "Vectorize.deleteByIds",
+      spanOptions(definition.binding, "deleteByIds"),
+    )((ids: ReadonlyArray<string>) =>
+      tryVectorizePromise(definition.binding, "deleteByIds", () => runtime.deleteByIds([...ids])),
+    );
 
     return {
       definition,
-      describe: tryVectorizePromise(definition.binding, "describe", () => runtime.describe()),
-      query: (vector, options) =>
+      describe: tryVectorizePromise(definition.binding, "describe", () => runtime.describe()).pipe(
+        Effect.withSpan("Vectorize.describe", spanOptions(definition.binding, "describe")),
+      ),
+      query: Effect.fn(
+        "Vectorize.query",
+        spanOptions(definition.binding, "query"),
+      )((vector: VectorizeValues, options?: VectorizeQueryOptions) =>
         tryVectorizePromise(definition.binding, "query", () =>
           runtime.query(vector as Float32Array | Float64Array | number[], options),
         ),
-      queryById: (vectorId, options) =>
+      ),
+      queryById: Effect.fn(
+        "Vectorize.queryById",
+        spanOptions(definition.binding, "queryById"),
+      )((vectorId: string, options?: VectorizeQueryOptions) =>
         runtime.queryById !== undefined
           ? tryVectorizePromise(definition.binding, "queryById", () =>
               runtime.queryById!(vectorId, options),
@@ -177,15 +209,28 @@ export const makeClient =
                 new TypeError("Vectorize binding does not expose queryById()"),
               ),
             ),
-      insert: (vectors) =>
+      ),
+      insert: Effect.fn(
+        "Vectorize.insert",
+        spanOptions(definition.binding, "insert"),
+      )((vectors: ReadonlyArray<VectorizeVector>) =>
         tryVectorizePromise(definition.binding, "insert", () => runtime.insert([...vectors])),
-      upsert: (vectors) =>
+      ),
+      upsert: Effect.fn(
+        "Vectorize.upsert",
+        spanOptions(definition.binding, "upsert"),
+      )((vectors: ReadonlyArray<VectorizeVector>) =>
         tryVectorizePromise(definition.binding, "upsert", () => runtime.upsert([...vectors])),
+      ),
       deleteByIds,
       delete: deleteByIds,
-      getByIds: (ids) =>
+      getByIds: Effect.fn(
+        "Vectorize.getByIds",
+        spanOptions(definition.binding, "getByIds"),
+      )((ids: ReadonlyArray<string>) =>
         tryVectorizePromise(definition.binding, "getByIds", () => runtime.getByIds([...ids])),
-      unsafeRaw: Effect.succeed(index),
+      ),
+      rawUnsafe: Effect.succeed(index),
     };
   };