effect-cf 0.6.0 → 0.7.0

package/src/Kv.ts

@@ -1,8 +1,7 @@
-import { Data, Effect, Option, Schema as S } from "effect";
+import { Context, Data, Effect, Option, Schema as S, type Layer } from "effect";
 
 import * as Binding from "./Binding";
-
-const TypeId = "effect-cf/Kv" as const;
+import type { WorkerEnvironment } from "./Environment";
 
 /** Error raised when a KV operation fails. */
 export class KvOperationError extends Data.TaggedError("KvOperationError")<{
@@ -72,18 +71,6 @@ export namespace Definition {
   export type Any = Definition<string, any, any, any>;
 }
 
-declare const KvServiceTypeId: unique symbol;
-
-/** Nominal service marker for KV services created with {@link make}. */
-export interface KvService<Id extends string, Key, Value, EncodedValue> {
-  readonly [KvServiceTypeId]: {
-    readonly id: Id;
-    readonly key: Key;
-    readonly value: Value;
-    readonly encodedValue: EncodedValue;
-  };
-}
-
 export interface KvClient<Key, Value, EncodedValue> {
   readonly put: (
     key: Key,
@@ -106,14 +93,48 @@ export interface KvClient<Key, Value, EncodedValue> {
   readonly definition: KvDefinition<Key, Value, EncodedValue>;
 }
 
-declare const BindingServiceTypeId: unique symbol;
+export type LayerOptions = {
+  readonly binding: string;
+};
 
-/** Nominal service marker for KV bindings created from a reusable {@link Definition}. */
-export interface BindingService<Id extends string, Self extends Definition.Any> {
-  readonly [BindingServiceTypeId]: {
-    readonly id: Id;
-    readonly definition: Self;
-  };
+export interface TagClass<
+  Self,
+  Id extends string,
+  Key,
+  Value,
+  EncodedValue,
+> extends Context.ServiceClass<Self, Id, KvClient<Key, Value, EncodedValue>> {
+  readonly id: Id;
+  readonly keySchema: S.Codec<Key, string>;
+  readonly valueSchema: S.Codec<Value, EncodedValue>;
+  readonly layer: (
+    options: LayerOptions,
+  ) => Layer.Layer<
+    Self,
+    Binding.BindingNotFoundError | Binding.BindingValidationError,
+    WorkerEnvironment
+  >;
+  readonly put: (
+    key: Key,
+    value: Value,
+    options?: KvPutOptions,
+  ) => Effect.Effect<void, KvOperationError | S.SchemaError, Self>;
+  readonly get: (
+    key: Key,
+  ) => Effect.Effect<Option.Option<Value>, KvOperationError | S.SchemaError, Self>;
+  readonly getWithMetadata: <Metadata>(
+    key: Key,
+    metadataSchema: S.Codec<Metadata, unknown>,
+  ) => Effect.Effect<
+    Option.Option<KvWithMetadata<Value, Metadata>>,
+    KvOperationError | S.SchemaError,
+    Self
+  >;
+  readonly list: <Metadata = unknown>(
+    options?: KvListOptions<Metadata>,
+  ) => Effect.Effect<KvListResult<Key, Metadata>, KvOperationError | S.SchemaError, Self>;
+  readonly remove: (key: Key) => Effect.Effect<void, KvOperationError | S.SchemaError, Self>;
+  readonly unsafeRaw: () => Effect.Effect<KVNamespace, never, Self>;
 }
 
 const maybeString = (value: string | null | undefined): Option.Option<string> =>
@@ -135,14 +156,122 @@ const tryKvPromise = <A>(
     catch: (cause) => kvError(binding, operation, cause),
   });
 
-/**
- * Creates a typed KV service tag plus Effect helpers.
- */
-export const make = <Id extends string, Key, Value, EncodedValue>(
-  id: Id,
+export const isKvNamespace = (value: unknown): 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"
+  );
+};
+
+export const makeClient = <Key, Value, EncodedValue>(
+  definition: KvDefinition<Key, Value, EncodedValue>,
+): ((kv: KVNamespace) => KvClient<Key, Value, EncodedValue>) => {
+  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)));
+
+  return (kv) => ({
+    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),
+  });
+};
+
+export const layer = <Self, Key, Value, EncodedValue>(
+  tag: Context.Service<Self, KvClient<Key, Value, EncodedValue>>,
   definition: KvDefinition<Key, Value, EncodedValue>,
 ) =>
-  Service<KvService<Id, Key, Value, EncodedValue>>()<Id, Key, Value, EncodedValue>(id, definition);
+  Binding.layer(
+    tag,
+    definition.binding,
+    isKvNamespace,
+    makeClient<Key, Value, EncodedValue>(definition),
+  );
 
 const makeDefinition = <Id extends string, Key, Value, EncodedValue>(
   id: Id,
@@ -156,34 +285,20 @@ const makeDefinition = <Id extends string, Key, Value, EncodedValue>(
   };
 
   return Object.assign(kvDefinition, {
-    Binding:
-      <Self>() =>
-      <BindingId extends string>(
-        bindingId: BindingId,
-        binding: Omit<KvDefinition<Key, Value, EncodedValue>, "key" | "value">,
-      ) =>
-        Service<Self>()<BindingId, Key, Value, EncodedValue>(bindingId, {
-          ...binding,
-          key: definition.key,
-          value: definition.value,
-        }),
-    binding: <BindingId extends string>(
-      bindingId: BindingId,
-      binding: Omit<KvDefinition<Key, Value, EncodedValue>, "key" | "value">,
+    layer: <Self>(
+      tag: Context.Service<Self, KvClient<Key, Value, EncodedValue>>,
+      binding: LayerOptions,
     ) =>
-      Service<BindingService<BindingId, SelfDefinition>>()<BindingId, Key, Value, EncodedValue>(
-        bindingId,
-        {
-          ...binding,
-          key: definition.key,
-          value: definition.value,
-        },
-      ),
+      layer(tag, {
+        ...binding,
+        key: definition.key,
+        value: definition.value,
+      }),
   });
 };
 
 export const Tag =
-  <_Self>() =>
+  <Self>() =>
   <Id extends string, Key, Value, EncodedValue>(
     id: Id,
     definition: {
@@ -192,152 +307,9 @@ export const Tag =
     },
   ) => {
     const kvDefinition = makeDefinition(id, definition);
+    const tag = Context.Service<Self, KvClient<Key, Value, EncodedValue>>()(id);
 
-    abstract class KvDefinitionClass {
-      static readonly id = kvDefinition.id;
-      static readonly key = kvDefinition.key;
-      static readonly value = kvDefinition.value;
-      static readonly Binding = kvDefinition.Binding;
-      static readonly binding = kvDefinition.binding;
-    }
-
-    return KvDefinitionClass as (abstract new () => object) & typeof kvDefinition;
-  };
-
-/**
- * Builds a KV service around a Cloudflare KV namespace binding.
- *
- * Returned service includes schema-aware `put`, `get`, `getWithMetadata`,
- * `list`, and `remove` helpers.
- *
- * @example
- * ```ts
- * const Sessions = Kv.make("Sessions", {
- *   binding: "SESSIONS",
- *   key: Schema.String,
- *   value: Schema.Struct({ userId: Schema.String }),
- * });
- *
- * const program = Effect.gen(function* () {
- *   yield* Sessions.put("abc", { userId: "u_1" });
- *   return yield* Sessions.get("abc");
- * });
- * ```
- */
-export const Service =
-  <Self>() =>
-  <Id extends string, Key, Value, EncodedValue>(
-    id: Id,
-    definition: KvDefinition<Key, Value, EncodedValue>,
-  ) => {
-    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 makeLayer = (binding: LayerOptions) => kvDefinition.layer(tag, binding);
 
     const put = Effect.fnUntraced(function* (key: Key, value: Value, options?: KvPutOptions) {
       const kv = yield* tag;
@@ -375,13 +347,15 @@ export const Service =
     });
 
     return Object.assign(tag, {
-      [TypeId]: TypeId,
-      definition,
+      id: kvDefinition.id,
+      keySchema: kvDefinition.key,
+      valueSchema: kvDefinition.value,
+      layer: makeLayer,
       put,
       get,
       getWithMetadata,
       list,
       remove,
       unsafeRaw,
-    });
+    }) as TagClass<Self, Id, Key, Value, EncodedValue>;
   };

package/src/Queue.ts

@@ -91,10 +91,6 @@ export const decodeBatch = <Body>(
     return fromMessageBatch(batch, messages);
   });
 
-export const Tag = QueueDefinition.Tag;
-
-export const implement = QueueDefinition.implement;
-
 export type Definition<
   Id extends string = string,
   Message extends QueueDefinition.Definition.Any["message"] =
@@ -105,6 +101,24 @@ export namespace Definition {
   export type Any = QueueDefinition.Definition.Any;
 }
 
+export type LayerOptions = QueueDefinition.LayerOptions;
+
+export type TagClass<
+  Self,
+  Id extends string,
+  Message extends QueueDefinition.Definition.Any["message"],
+> = QueueDefinition.TagClass<Self, Id, Message>;
+
+export const Tag: <Self>() => <
+  Id extends string,
+  Message extends QueueDefinition.Definition.Any["message"],
+>(
+  id: Id,
+  definition: { readonly message: Message },
+) => TagClass<Self, Id, Message> = QueueDefinition.Tag;
+
+export const implement = QueueDefinition.implement;
+
 export type Handler<ROut, Self extends QueueDefinition.Definition.Any> = QueueDefinition.Handler<
   ROut,
   Self

package/src/QueueBinding.ts

@@ -1,10 +1,8 @@
-import { Data, Effect, Schema as S } from "effect";
+import { Context, Data, Effect, Schema as S } from "effect";
 
 import * as Binding from "./Binding";
 import type * as RpcDefinition from "./RpcDefinition";
 
-const TypeId = "effect-cf/QueueBinding" as const;
-
 export type QueueSendOptions = globalThis.QueueSendOptions;
 export type QueueSendResponse = globalThis.QueueSendResponse;
 export type QueueSendBatchOptions = globalThis.QueueSendBatchOptions;
@@ -32,17 +30,6 @@ export interface QueueBindingClient<Message extends RpcDefinition.ServiceFreeSch
   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}. */
-export interface QueueService<Id extends string, Message extends RpcDefinition.ServiceFreeSchema> {
-  readonly [QueueServiceTypeId]: {
-    readonly id: Id;
-    readonly message: S.Schema.Type<Message>;
-    readonly encodedMessage: S.Codec.Encoded<Message>;
-  };
-}
-
 export class QueueOperationError extends Data.TaggedError("QueueOperationError")<{
   readonly binding: string;
   readonly operation: string;
@@ -62,7 +49,7 @@ const tryQueuePromise = <A>(
     catch: (cause) => queueError(binding, operation, cause),
   });
 
-const isQueue = <Body>(value: unknown): value is globalThis.Queue<Body> => {
+export const isQueue = <Body>(value: unknown): value is globalThis.Queue<Body> => {
   if (typeof value !== "object" || value === null) {
     return false;
   }
@@ -76,89 +63,50 @@ const isQueue = <Body>(value: unknown): value is globalThis.Queue<Body> => {
   );
 };
 
-/** Creates a typed Queue binding service tag plus Effect helpers. */
-export const make = <Id extends string, Message extends RpcDefinition.ServiceFreeSchema>(
-  id: Id,
+export const makeClient = <Message extends RpcDefinition.ServiceFreeSchema>(
   definition: QueueBindingDefinition<Message>,
-) => Service<QueueService<Id, Message>>()<Id, Message>(id, definition);
-
-/**
- * Builds an Effect service around a Cloudflare Queue producer binding.
- */
-export const Service =
-  <Self>() =>
-  <Id extends string, Message extends RpcDefinition.ServiceFreeSchema>(
-    id: Id,
-    definition: QueueBindingDefinition<Message>,
-  ) => {
-    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 send = Effect.fnUntraced(function* (message: Body, options?: QueueSendOptions) {
-      const queue = yield* tag;
-      yield* queue.send(message, options);
-    });
-
-    const sendBatch = Effect.fnUntraced(function* (
+): ((queue: globalThis.Queue<S.Codec.Encoded<Message>>) => QueueBindingClient<Message>) => {
+  type Body = S.Schema.Type<Message>;
+  type EncodedBody = S.Codec.Encoded<Message>;
+
+  const encodeMessage = S.encodeEffect(definition.message);
+
+  return (queue) => ({
+    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 queue = yield* tag;
-      yield* queue.sendBatch(messages, options);
-    });
-
-    const metrics = Effect.fnUntraced(function* () {
-      const queue = yield* tag;
-      return yield* queue.metrics();
-    });
-
-    const unsafeRaw = Effect.fnUntraced(function* () {
-      const queue = yield* tag;
-      return yield* queue.unsafeRaw;
-    });
-
-    return Object.assign(tag, {
-      [TypeId]: TypeId,
-      binding: definition.binding,
-      send,
-      sendBatch,
-      metrics,
-      unsafeRaw,
-    });
-  };
+      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),
+  });
+};
+
+export const layer = <Self, Message extends RpcDefinition.ServiceFreeSchema>(
+  tag: Context.Service<Self, QueueBindingClient<Message>>,
+  definition: QueueBindingDefinition<Message>,
+) =>
+  Binding.layer(
+    tag,
+    definition.binding,
+    (value): value is globalThis.Queue<S.Codec.Encoded<Message>> =>
+      isQueue<S.Codec.Encoded<Message>>(value),
+    makeClient(definition),
+  );