effect-cf 0.4.0 → 0.6.0

package/src/Kv.ts

@@ -84,6 +84,28 @@ export interface KvService<Id extends string, Key, Value, EncodedValue> {
   };
 }
 
+export interface KvClient<Key, Value, EncodedValue> {
+  readonly put: (
+    key: Key,
+    value: Value,
+    options?: KvPutOptions,
+  ) => Effect.Effect<void, KvOperationError | S.SchemaError>;
+  readonly get: (key: Key) => Effect.Effect<Option.Option<Value>, KvOperationError | S.SchemaError>;
+  readonly getWithMetadata: <Metadata>(
+    key: Key,
+    metadataSchema: S.Codec<Metadata, unknown>,
+  ) => Effect.Effect<
+    Option.Option<KvWithMetadata<Value, Metadata>>,
+    KvOperationError | S.SchemaError
+  >;
+  readonly list: <Metadata = unknown>(
+    options?: KvListOptions<Metadata>,
+  ) => Effect.Effect<KvListResult<Key, Metadata>, KvOperationError | S.SchemaError>;
+  readonly remove: (key: Key) => Effect.Effect<void, KvOperationError | S.SchemaError>;
+  readonly unsafeRaw: Effect.Effect<KVNamespace>;
+  readonly definition: KvDefinition<Key, Value, EncodedValue>;
+}
+
 declare const BindingServiceTypeId: unique symbol;
 
 /** Nominal service marker for KV bindings created from a reusable {@link Definition}. */
@@ -208,46 +230,123 @@ export const Service =
     id: Id,
     definition: KvDefinition<Key, Value, EncodedValue>,
   ) => {
-    const tag = Binding.Service<Self>()(id, definition.binding, (value): value is KVNamespace => {
-      if (typeof value !== "object" || value === null) {
-        return false;
-      }
-
-      const resource = value as Record<string, unknown>;
-
-      return (
-        typeof resource.get === "function" &&
-        typeof resource.put === "function" &&
-        typeof resource.delete === "function" &&
-        typeof resource.getWithMetadata === "function" &&
-        typeof resource.list === "function"
-      );
-    });
-
     const encodeKey = S.encodeEffect(definition.key);
     const decodeKey = S.decodeUnknownEffect(definition.key);
     const encodeValue = S.encodeEffect(S.fromJsonString(S.toCodecJson(definition.value)));
     const decodeValue = S.decodeUnknownEffect(S.fromJsonString(S.toCodecJson(definition.value)));
 
+    const makeClient = (kv: KVNamespace): KvClient<Key, Value, EncodedValue> => ({
+      definition,
+      put: Effect.fnUntraced(function* (key: Key, value: Value, options?: KvPutOptions) {
+        const keyEncoded = yield* encodeKey(key);
+        const valueEncoded = yield* encodeValue(value);
+        yield* tryKvPromise(definition.binding, "put", () =>
+          kv.put(keyEncoded, valueEncoded, options),
+        );
+      }),
+      get: Effect.fnUntraced(function* (key: Key) {
+        const keyEncoded = yield* encodeKey(key);
+        const valueEncoded = yield* tryKvPromise(definition.binding, "get", () =>
+          kv.get(keyEncoded),
+        );
+
+        if (valueEncoded === null) {
+          return Option.none();
+        }
+
+        return yield* decodeValue(valueEncoded).pipe(Effect.map(Option.some));
+      }),
+      getWithMetadata: Effect.fnUntraced(function* <Metadata>(
+        key: Key,
+        metadataSchema: S.Codec<Metadata, unknown>,
+      ) {
+        const keyEncoded = yield* encodeKey(key);
+        const result = yield* tryKvPromise(definition.binding, "getWithMetadata", () =>
+          kv.getWithMetadata<Metadata>(keyEncoded),
+        );
+
+        if (result.value === null) {
+          return Option.none();
+        }
+
+        const value = yield* decodeValue(result.value);
+        const metadata =
+          result.metadata === null
+            ? Option.none<Metadata>()
+            : Option.some(yield* S.decodeUnknownEffect(metadataSchema)(result.metadata));
+
+        return Option.some({
+          value,
+          metadata,
+          cacheStatus: maybeString(result.cacheStatus),
+        });
+      }),
+      list: Effect.fnUntraced(function* <Metadata = unknown>(options?: KvListOptions<Metadata>) {
+        const { metadataSchema, ...kvOptions } = options ?? {};
+        const result = yield* tryKvPromise(definition.binding, "list", () =>
+          kv.list<Metadata>(kvOptions),
+        );
+        const keys: Array<KvListKey<Key, Metadata>> = [];
+
+        for (const key of result.keys) {
+          const decodedName = yield* decodeKey(key.name);
+          const decodedMetadata =
+            key.metadata === undefined
+              ? Option.none<Metadata>()
+              : metadataSchema === undefined
+                ? Option.some(key.metadata as Metadata)
+                : Option.some(yield* S.decodeUnknownEffect(metadataSchema)(key.metadata));
+
+          keys.push({
+            name: decodedName,
+            expiration: maybeNumber(key.expiration),
+            metadata: decodedMetadata,
+          });
+        }
+
+        return {
+          keys,
+          listComplete: result.list_complete,
+          cursor: maybeString("cursor" in result ? result.cursor : undefined),
+          cacheStatus: maybeString(result.cacheStatus),
+        };
+      }),
+      remove: Effect.fnUntraced(function* (key: Key) {
+        const keyEncoded = yield* encodeKey(key);
+        yield* tryKvPromise(definition.binding, "delete", () => kv.delete(keyEncoded));
+      }),
+      unsafeRaw: Effect.succeed(kv),
+    });
+
+    const tag = Binding.Service<Self>()(
+      id,
+      definition.binding,
+      (value): value is KVNamespace => {
+        if (typeof value !== "object" || value === null) {
+          return false;
+        }
+
+        const resource = value as Record<string, unknown>;
+
+        return (
+          typeof resource.get === "function" &&
+          typeof resource.put === "function" &&
+          typeof resource.delete === "function" &&
+          typeof resource.getWithMetadata === "function" &&
+          typeof resource.list === "function"
+        );
+      },
+      makeClient,
+    );
+
     const put = Effect.fnUntraced(function* (key: Key, value: Value, options?: KvPutOptions) {
       const kv = yield* tag;
-      const keyEncoded = yield* encodeKey(key);
-      const valueEncoded = yield* encodeValue(value);
-      yield* tryKvPromise(definition.binding, "put", () =>
-        kv.put(keyEncoded, valueEncoded, options),
-      );
+      yield* kv.put(key, value, options);
     });
 
     const get = Effect.fnUntraced(function* (key: Key) {
       const kv = yield* tag;
-      const keyEncoded = yield* encodeKey(key);
-      const valueEncoded = yield* tryKvPromise(definition.binding, "get", () => kv.get(keyEncoded));
-
-      if (valueEncoded === null) {
-        return Option.none();
-      }
-
-      return yield* decodeValue(valueEncoded).pipe(Effect.map(Option.some));
+      return yield* kv.get(key);
     });
 
     const getWithMetadata = Effect.fnUntraced(function* <Metadata>(
@@ -255,70 +354,24 @@ export const Service =
       metadataSchema: S.Codec<Metadata, unknown>,
     ) {
       const kv = yield* tag;
-      const keyEncoded = yield* encodeKey(key);
-      const result = yield* tryKvPromise(definition.binding, "getWithMetadata", () =>
-        kv.getWithMetadata<Metadata>(keyEncoded),
-      );
-
-      if (result.value === null) {
-        return Option.none();
-      }
-
-      const value = yield* decodeValue(result.value);
-      const metadata =
-        result.metadata === null
-          ? Option.none<Metadata>()
-          : Option.some(yield* S.decodeUnknownEffect(metadataSchema)(result.metadata));
-
-      return Option.some({
-        value,
-        metadata,
-        cacheStatus: maybeString(result.cacheStatus),
-      });
+      return yield* kv.getWithMetadata(key, metadataSchema);
     });
 
     const list = Effect.fnUntraced(function* <Metadata = unknown>(
       options?: KvListOptions<Metadata>,
     ) {
       const kv = yield* tag;
-      const { metadataSchema, ...kvOptions } = options ?? {};
-      const result = yield* tryKvPromise(definition.binding, "list", () =>
-        kv.list<Metadata>(kvOptions),
-      );
-      const keys: Array<KvListKey<Key, Metadata>> = [];
-
-      for (const key of result.keys) {
-        const decodedName = yield* decodeKey(key.name);
-        const decodedMetadata =
-          key.metadata === undefined
-            ? Option.none<Metadata>()
-            : metadataSchema === undefined
-              ? Option.some(key.metadata as Metadata)
-              : Option.some(yield* S.decodeUnknownEffect(metadataSchema)(key.metadata));
-
-        keys.push({
-          name: decodedName,
-          expiration: maybeNumber(key.expiration),
-          metadata: decodedMetadata,
-        });
-      }
-
-      return {
-        keys,
-        listComplete: result.list_complete,
-        cursor: maybeString("cursor" in result ? result.cursor : undefined),
-        cacheStatus: maybeString(result.cacheStatus),
-      };
+      return yield* kv.list(options);
     });
 
     const remove = Effect.fnUntraced(function* (key: Key) {
       const kv = yield* tag;
-      const keyEncoded = yield* encodeKey(key);
-      yield* tryKvPromise(definition.binding, "delete", () => kv.delete(keyEncoded));
+      yield* kv.remove(key);
     });
 
     const unsafeRaw = Effect.fnUntraced(function* () {
-      return yield* tag;
+      const kv = yield* tag;
+      return yield* kv.unsafeRaw;
     });
 
     return Object.assign(tag, {

package/src/QueueBinding.ts

@@ -19,6 +19,19 @@ export interface QueueBindingDefinition<Message extends RpcDefinition.ServiceFre
   readonly message: Message;
 }
 
+export interface QueueBindingClient<Message extends RpcDefinition.ServiceFreeSchema> {
+  readonly send: (
+    message: S.Schema.Type<Message>,
+    options?: QueueSendOptions,
+  ) => Effect.Effect<void, QueueOperationError | S.SchemaError>;
+  readonly sendBatch: (
+    messages: Iterable<MessageSendRequest<S.Schema.Type<Message>>>,
+    options?: QueueSendBatchOptions,
+  ) => Effect.Effect<void, QueueOperationError | S.SchemaError>;
+  readonly metrics: () => Effect.Effect<QueueMetrics, QueueOperationError>;
+  readonly unsafeRaw: Effect.Effect<globalThis.Queue<S.Codec.Encoded<Message>>>;
+}
+
 declare const QueueServiceTypeId: unique symbol;
 
 /** Nominal service marker for Queue services created with {@link make}. */
@@ -81,19 +94,45 @@ export const Service =
     type Body = S.Schema.Type<Message>;
     type EncodedBody = S.Codec.Encoded<Message>;
 
+    const encodeMessage = S.encodeEffect(definition.message);
+
+    const makeClient = (queue: globalThis.Queue<EncodedBody>): QueueBindingClient<Message> => ({
+      send: Effect.fnUntraced(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,
+      ) {
+        const encodedMessages: Array<MessageSendRequest<EncodedBody>> = [];
+
+        for (const message of messages) {
+          encodedMessages.push({
+            ...message,
+            body: yield* encodeMessage(message.body),
+          });
+        }
+
+        yield* tryQueuePromise(definition.binding, "sendBatch", () =>
+          queue.sendBatch(encodedMessages, options),
+        );
+      }),
+      metrics: () => tryQueuePromise(definition.binding, "metrics", () => queue.metrics()),
+      unsafeRaw: Effect.succeed(queue),
+    });
+
     const tag = Binding.Service<Self>()(
       id,
       definition.binding,
       (value): value is globalThis.Queue<EncodedBody> => isQueue<EncodedBody>(value),
+      makeClient,
     );
 
-    const encodeMessage = S.encodeEffect(definition.message);
-
     const send = Effect.fnUntraced(function* (message: Body, options?: QueueSendOptions) {
       const queue = yield* tag;
-      const encoded = yield* encodeMessage(message);
-
-      return yield* tryQueuePromise(definition.binding, "send", () => queue.send(encoded, options));
+      yield* queue.send(message, options);
     });
 
     const sendBatch = Effect.fnUntraced(function* (
@@ -101,24 +140,17 @@ export const Service =
       options?: QueueSendBatchOptions,
     ) {
       const queue = yield* tag;
-      const encodedMessages: Array<MessageSendRequest<EncodedBody>> = [];
-
-      for (const message of messages) {
-        encodedMessages.push({
-          ...message,
-          body: yield* encodeMessage(message.body),
-        });
-      }
-
-      return yield* tryQueuePromise(definition.binding, "sendBatch", () =>
-        queue.sendBatch(encodedMessages, options),
-      );
+      yield* queue.sendBatch(messages, options);
     });
 
     const metrics = Effect.fnUntraced(function* () {
       const queue = yield* tag;
+      return yield* queue.metrics();
+    });
 
-      return yield* tryQueuePromise(definition.binding, "metrics", () => queue.metrics());
+    const unsafeRaw = Effect.fnUntraced(function* () {
+      const queue = yield* tag;
+      return yield* queue.unsafeRaw;
     });
 
     return Object.assign(tag, {
@@ -127,5 +159,6 @@ export const Service =
       send,
       sendBatch,
       metrics,
+      unsafeRaw,
     });
   };

package/src/ServiceBinding.ts

@@ -1,4 +1,4 @@
-import { Data, Effect } from "effect";
+import { Data, Effect, type Scope } from "effect";
 
 import * as Binding from "./Binding";
 import * as CloudflareRpc from "./Rpc";
@@ -75,25 +75,47 @@ type ServiceMethodSuccess<Api, Method extends keyof Api> = RpcInvocation.AsyncMe
   Method
 >;
 
-type ServiceCall<Self, Api> = <Method extends ServiceMethodKey<Api>>(
+type ServiceCall<R, Api> = <Method extends ServiceMethodKey<Api>>(
   method: Method,
   ...args: ServiceMethodArgs<Api, Method>
-) => Effect.Effect<ServiceMethodSuccess<Api, Method>, ServiceBindingRpcError, Self>;
+) => Effect.Effect<ServiceMethodSuccess<Api, Method>, ServiceBindingRpcError, R>;
 
-type DefinitionDirectMethods<Self, Definition extends WorkerDefinition.Definition.Any> = {
+type DefinitionDirectMethods<R, Definition extends WorkerDefinition.Definition.Any> = {
   readonly [Method in RpcDefinition.Definition.MethodNames<Definition>]: (
     ...args: RpcDefinition.Method.Args<Definition["methods"][Method]>
   ) => Effect.Effect<
     RpcDefinition.Method.Success<Definition["methods"][Method]>,
     ServiceBindingRpcError,
-    Self
+    R
   >;
 };
 
-type DirectMethods<Self, Definition> = Definition extends WorkerDefinition.Definition.Any
-  ? DefinitionDirectMethods<Self, Definition>
+type DirectMethods<R, Definition> = Definition extends WorkerDefinition.Definition.Any
+  ? DefinitionDirectMethods<R, Definition>
   : {};
 
+export type ServiceBindingEffectClient<
+  Api extends object,
+  Definition extends WorkerDefinition.Definition.Any | undefined = undefined,
+> = DirectMethods<never, Definition> & {
+  readonly fetch: (
+    input: RequestInfo | URL,
+    init?: RequestInit,
+  ) => Effect.Effect<globalThis.Response, ServiceBindingFetchError>;
+  readonly rpc: <Method extends ServiceMethodKey<Api>>(
+    method: Method,
+    ...args: ServiceMethodArgs<Api, Method>
+  ) => Effect.Effect<ServiceMethodSuccess<Api, Method>, ServiceBindingRpcError>;
+  readonly call: <Method extends ServiceMethodKey<Api>>(
+    method: Method,
+    ...args: ServiceMethodArgs<Api, Method>
+  ) => Effect.Effect<ServiceMethodSuccess<Api, Method>, ServiceBindingRpcError>;
+  readonly scopedCall: <Method extends ServiceMethodKey<Api>>(
+    method: Method,
+    ...args: ServiceMethodArgs<Api, Method>
+  ) => Effect.Effect<Awaited<ServiceMethodSuccess<Api, Method>>, unknown, Scope.Scope>;
+};
+
 /**
  * Creates a typed Effect service for a Worker service binding.
  *
@@ -131,21 +153,125 @@ export const Service =
   ) => {
     type ServiceApi = ApiOrDefinition<Api, Definition>;
 
+    const makeClient = (
+      service: ServiceBindingClient<ServiceApi>,
+    ): ServiceBindingEffectClient<ServiceApi, Definition> => {
+      const fetch = (input: RequestInfo | URL, init?: RequestInit) =>
+        Effect.tryPromise({
+          try: () => service.fetch(input, init),
+          catch: (cause) => new ServiceBindingFetchError({ binding: definition.binding, cause }),
+        });
+
+      const rpc = <Method extends ServiceMethodKey<ServiceApi>>(
+        method: Method,
+        ...args: ServiceMethodArgs<ServiceApi, 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<ServiceApi, Method>,
+            (cause) =>
+              new ServiceBindingRpcError({
+                binding: definition.binding,
+                method: methodName,
+                cause,
+              }),
+          );
+        });
+
+      const call = <Method extends ServiceMethodKey<ServiceApi>>(
+        method: Method,
+        ...args: ServiceMethodArgs<ServiceApi, 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,
+                }),
+            ),
+          );
+
+          if (definition.definition === undefined) {
+            return value as ServiceMethodSuccess<ServiceApi, 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<ServiceApi, Method>;
+        });
+
+      const scopedCall = <Method extends ServiceMethodKey<ServiceApi>>(
+        method: Method,
+        ...args: ServiceMethodArgs<ServiceApi, Method>
+      ) =>
+        Effect.gen(function* () {
+          const result = yield* rpc(method, ...args);
+          return yield* CloudflareRpc.scoped(result);
+        });
+
+      const directMethods = makeDirectMethods<never, ServiceApi, Definition>(
+        definition.definition,
+        call,
+      );
+
+      return Object.assign(directMethods, {
+        fetch,
+        rpc,
+        call,
+        scopedCall,
+      }) as ServiceBindingEffectClient<ServiceApi, Definition>;
+    };
+
     const tag = Binding.Service<Self>()(
       id,
       definition.binding,
       (value): value is ServiceBindingClient<ServiceApi> =>
         typeof value === "object" && value !== null && "fetch" in value,
+      makeClient,
     );
 
     const fetch = (input: RequestInfo | URL, init?: RequestInit) =>
       Effect.gen(function* () {
         const service = yield* tag;
-
-        return yield* Effect.tryPromise({
-          try: () => service.fetch(input, init),
-          catch: (cause) => new ServiceBindingFetchError({ binding: definition.binding, cause }),
-        });
+        return yield* service.fetch(input, init);
       });
 
     const rpc = <Method extends ServiceMethodKey<ServiceApi>>(
@@ -154,36 +280,7 @@ export const Service =
     ) =>
       Effect.gen(function* () {
         const service = yield* tag;
-        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<ServiceApi, Method>,
-          (cause) =>
-            new ServiceBindingRpcError({
-              binding: definition.binding,
-              method: methodName,
-              cause,
-            }),
-        );
+        return yield* service.rpc(method, ...args);
       });
 
     const call = <Method extends ServiceMethodKey<ServiceApi>>(
@@ -191,38 +288,8 @@ export const Service =
       ...args: ServiceMethodArgs<ServiceApi, 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,
-              }),
-          ),
-        );
-
-        if (definition.definition === undefined) {
-          return value as ServiceMethodSuccess<ServiceApi, 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<ServiceApi, Method>;
+        const service = yield* tag;
+        return yield* service.call(method, ...args);
       });
 
     const scopedCall = <Method extends ServiceMethodKey<ServiceApi>>(
@@ -230,8 +297,8 @@ export const Service =
       ...args: ServiceMethodArgs<ServiceApi, Method>
     ) =>
       Effect.gen(function* () {
-        const result = yield* rpc(method, ...args);
-        return yield* CloudflareRpc.scoped(result);
+        const service = yield* tag;
+        return yield* service.scopedCall(method, ...args);
       });
 
     const directMethods = makeDirectMethods<Self, ServiceApi, Definition>(
@@ -257,14 +324,10 @@ export const Service =
       };
   };
 
-const makeDirectMethods = <
-  Self,
-  Api,
-  Definition extends WorkerDefinition.Definition.Any | undefined,
->(
+const makeDirectMethods = <R, Api, Definition extends WorkerDefinition.Definition.Any | undefined>(
   rpcDefinition: Definition | undefined,
-  call: ServiceCall<Self, Api>,
-): DirectMethods<Self, Definition> => {
+  call: ServiceCall<R, Api>,
+): DirectMethods<R, Definition> => {
   const methods = {} as Record<string, unknown>;
 
   if (rpcDefinition !== undefined) {
@@ -274,5 +337,5 @@ const makeDirectMethods = <
     }
   }
 
-  return methods as DirectMethods<Self, Definition>;
+  return methods as DirectMethods<R, Definition>;
 };

package/src/index.ts

@@ -1,4 +1,5 @@
 export * as Binding from "./Binding";
+export * as D1 from "./D1";
 export * as DurableObject from "./DurableObject";
 export * as DurableObjectAlarm from "./DurableObjectAlarm";
 export * as DurableObjectDefinition from "./DurableObjectDefinition";