effect-cf 0.5.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,26 +71,70 @@ 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,
+    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;
+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> =>
@@ -113,133 +156,40 @@ 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,
-  definition: KvDefinition<Key, Value, EncodedValue>,
-) =>
-  Service<KvService<Id, Key, Value, EncodedValue>>()<Id, Key, Value, EncodedValue>(id, definition);
+export const isKvNamespace = (value: unknown): value is KVNamespace => {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
 
-const makeDefinition = <Id extends string, Key, Value, EncodedValue>(
-  id: Id,
-  definition: { readonly key: S.Codec<Key, string>; readonly value: S.Codec<Value, EncodedValue> },
-) => {
-  type SelfDefinition = Definition<Id, Key, Value, EncodedValue>;
-  const kvDefinition: SelfDefinition = {
-    id,
-    key: definition.key,
-    value: definition.value,
-  };
+  const resource = value as Record<string, unknown>;
 
-  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">,
-    ) =>
-      Service<BindingService<BindingId, SelfDefinition>>()<BindingId, Key, Value, EncodedValue>(
-        bindingId,
-        {
-          ...binding,
-          key: definition.key,
-          value: definition.value,
-        },
-      ),
-  });
+  return (
+    typeof resource.get === "function" &&
+    typeof resource.put === "function" &&
+    typeof resource.delete === "function" &&
+    typeof resource.getWithMetadata === "function" &&
+    typeof resource.list === "function"
+  );
 };
 
-export const Tag =
-  <_Self>() =>
-  <Id extends string, Key, Value, EncodedValue>(
-    id: Id,
-    definition: {
-      readonly key: S.Codec<Key, string>;
-      readonly value: S.Codec<Value, EncodedValue>;
-    },
-  ) => {
-    const kvDefinition = makeDefinition(id, definition);
-
-    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 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 put = Effect.fnUntraced(function* (key: Key, value: Value, options?: KvPutOptions) {
-      const kv = yield* tag;
+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),
       );
-    });
-
-    const get = Effect.fnUntraced(function* (key: Key) {
-      const kv = yield* tag;
+    }),
+    get: Effect.fnUntraced(function* (key: Key) {
       const keyEncoded = yield* encodeKey(key);
       const valueEncoded = yield* tryKvPromise(definition.binding, "get", () => kv.get(keyEncoded));
 
@@ -248,13 +198,11 @@ export const Service =
       }
 
       return yield* decodeValue(valueEncoded).pipe(Effect.map(Option.some));
-    });
-
-    const getWithMetadata = Effect.fnUntraced(function* <Metadata>(
+    }),
+    getWithMetadata: Effect.fnUntraced(function* <Metadata>(
       key: Key,
       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),
@@ -275,12 +223,8 @@ export const Service =
         metadata,
         cacheStatus: maybeString(result.cacheStatus),
       });
-    });
-
-    const list = Effect.fnUntraced(function* <Metadata = unknown>(
-      options?: KvListOptions<Metadata>,
-    ) {
-      const kv = yield* tag;
+    }),
+    list: Effect.fnUntraced(function* <Metadata = unknown>(options?: KvListOptions<Metadata>) {
       const { metadataSchema, ...kvOptions } = options ?? {};
       const result = yield* tryKvPromise(definition.binding, "list", () =>
         kv.list<Metadata>(kvOptions),
@@ -309,26 +253,109 @@ export const Service =
         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>,
+) =>
+  Binding.layer(
+    tag,
+    definition.binding,
+    isKvNamespace,
+    makeClient<Key, Value, EncodedValue>(definition),
+  );
+
+const makeDefinition = <Id extends string, Key, Value, EncodedValue>(
+  id: Id,
+  definition: { readonly key: S.Codec<Key, string>; readonly value: S.Codec<Value, EncodedValue> },
+) => {
+  type SelfDefinition = Definition<Id, Key, Value, EncodedValue>;
+  const kvDefinition: SelfDefinition = {
+    id,
+    key: definition.key,
+    value: definition.value,
+  };
+
+  return Object.assign(kvDefinition, {
+    layer: <Self>(
+      tag: Context.Service<Self, KvClient<Key, Value, EncodedValue>>,
+      binding: LayerOptions,
+    ) =>
+      layer(tag, {
+        ...binding,
+        key: definition.key,
+        value: definition.value,
+      }),
+  });
+};
+
+export const Tag =
+  <Self>() =>
+  <Id extends string, Key, Value, EncodedValue>(
+    id: Id,
+    definition: {
+      readonly key: S.Codec<Key, string>;
+      readonly value: S.Codec<Value, EncodedValue>;
+    },
+  ) => {
+    const kvDefinition = makeDefinition(id, definition);
+    const tag = Context.Service<Self, KvClient<Key, Value, EncodedValue>>()(id);
+
+    const makeLayer = (binding: LayerOptions) => kvDefinition.layer(tag, binding);
+
+    const put = Effect.fnUntraced(function* (key: Key, value: Value, options?: KvPutOptions) {
+      const kv = yield* tag;
+      yield* kv.put(key, value, options);
+    });
+
+    const get = Effect.fnUntraced(function* (key: Key) {
+      const kv = yield* tag;
+      return yield* kv.get(key);
+    });
+
+    const getWithMetadata = Effect.fnUntraced(function* <Metadata>(
+      key: Key,
+      metadataSchema: S.Codec<Metadata, unknown>,
+    ) {
+      const kv = yield* tag;
+      return yield* kv.getWithMetadata(key, metadataSchema);
+    });
+
+    const list = Effect.fnUntraced(function* <Metadata = unknown>(
+      options?: KvListOptions<Metadata>,
+    ) {
+      const kv = yield* tag;
+      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, {
-      [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;
@@ -19,15 +17,17 @@ export interface QueueBindingDefinition<Message extends RpcDefinition.ServiceFre
   readonly message: 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 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>>>;
 }
 
 export class QueueOperationError extends Data.TaggedError("QueueOperationError")<{
@@ -49,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;
   }
@@ -63,44 +63,24 @@ 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 tag = Binding.Service<Self>()(
-      id,
-      definition.binding,
-      (value): value is globalThis.Queue<EncodedBody> => isQueue<EncodedBody>(value),
-    );
-
-    const encodeMessage = S.encodeEffect(definition.message);
-
-    const send = Effect.fnUntraced(function* (message: Body, options?: QueueSendOptions) {
-      const queue = yield* tag;
-      const encoded = yield* encodeMessage(message);
+): ((queue: globalThis.Queue<S.Codec.Encoded<Message>>) => QueueBindingClient<Message>) => {
+  type Body = S.Schema.Type<Message>;
+  type EncodedBody = S.Codec.Encoded<Message>;
 
-      return yield* tryQueuePromise(definition.binding, "send", () => queue.send(encoded, options));
-    });
+  const encodeMessage = S.encodeEffect(definition.message);
+
+  return (queue) => ({
+    send: Effect.fnUntraced(function* (message: Body, options?: QueueSendOptions) {
+      const encoded = yield* encodeMessage(message);
 
-    const sendBatch = Effect.fnUntraced(function* (
+      yield* tryQueuePromise(definition.binding, "send", () => queue.send(encoded, options));
+    }),
+    sendBatch: Effect.fnUntraced(function* (
       messages: Iterable<MessageSendRequest<Body>>,
       options?: QueueSendBatchOptions,
     ) {
-      const queue = yield* tag;
       const encodedMessages: Array<MessageSendRequest<EncodedBody>> = [];
 
       for (const message of messages) {
@@ -110,22 +90,23 @@ export const Service =
         });
       }
 
-      return yield* tryQueuePromise(definition.binding, "sendBatch", () =>
+      yield* tryQueuePromise(definition.binding, "sendBatch", () =>
         queue.sendBatch(encodedMessages, options),
       );
-    });
-
-    const metrics = Effect.fnUntraced(function* () {
-      const queue = yield* tag;
-
-      return yield* tryQueuePromise(definition.binding, "metrics", () => queue.metrics());
-    });
-
-    return Object.assign(tag, {
-      [TypeId]: TypeId,
-      binding: definition.binding,
-      send,
-      sendBatch,
-      metrics,
-    });
-  };
+    }),
+    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),
+  );