effect-cf 0.5.0 → 0.7.0

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # effect-cf
 
+## 0.7.0
+
+### Minor Changes
+
+- [#20](https://github.com/danieljvdm/effect-cf/pull/20) [`f57a59c`](https://github.com/danieljvdm/effect-cf/commit/f57a59c14d317438348b36ac0341dc921fe72be2) Thanks [@danieljvdm](https://github.com/danieljvdm)! - Tighten binding APIs around Cloudflare RPC and the single-tag KV model. `rpc` now exposes the raw Cloudflare RPC result, while `call` and `scopedCall` resolve and decode definition-backed success values. Durable Object static direct helpers now keep the namespace layer requirement in their effect environment, and the old concrete `Kv.make` / `Kv.Service` constructors have been removed in favor of `Kv.Tag(...).layer({ binding })`.
+
+- [#19](https://github.com/danieljvdm/effect-cf/pull/19) [`37b4883`](https://github.com/danieljvdm/effect-cf/commit/37b4883de9790df151ddbb16f2fd432b2d4348b5) Thanks [@danieljvdm](https://github.com/danieljvdm)! - Replace separate binding classes with a single exported tag class API for Queues, Workflows, KV namespaces, Worker service bindings, and Durable Object namespaces. These tags now expose `layer({ binding })` directly, consumers use `const service = yield* Service`, and the old definition `.Binding(...)` / `.binding(...)` / `.Namespace(...)` / `.namespace(...)` helpers have been removed.
+
+## 0.6.0
+
+### Minor Changes
+
+- [#16](https://github.com/danieljvdm/effect-cf/pull/16) [`8195f35`](https://github.com/danieljvdm/effect-cf/commit/8195f356537bd8a063ddebe30f61d0028ddccba1) Thanks [@danieljvdm](https://github.com/danieljvdm)! - Provide Effect-native clients when yielding Queue, KV, Worker service, and Durable Object namespace binding tags, while keeping existing static helpers compatible.
+
 ## 0.5.0
 
 ### Minor Changes

package/README.md

@@ -32,20 +32,19 @@ Runtime creation belongs at Cloudflare entrypoints, not inside binding helpers.
 - `DurableObjectWebSocket` - WebSocket upgrade helpers for Durable Objects
 - `Kv` - typed KV namespace helper
 - `D1` - typed D1 database binding helper with an `@effect/sql-d1` backed SQL layer
-- `Queue` / `QueueBinding` - typed Queue producer bindings and consumer handlers
-- `Workflow` / `WorkflowBinding` - typed Workflow entrypoints, steps, and starter bindings
+- `Queue` - typed Queue producer/consumer tags plus client and error types
+- `Workflow` - typed Workflow entrypoints, steps, starter clients, and instance types
 - `Rpc` - Cloudflare RPC type helpers and scoped disposal utilities
 - `WorkerConfig` - Effect `Config` helpers backed by Cloudflare `env`
 
 ## Worker Example
 
 ```ts
-import { HttpServerResponse } from "effect";
+import { Effect, Layer } from "effect";
+import { HttpServerResponse } from "effect/unstable/http";
 import { Worker } from "effect-cf";
 
-export default Worker.make({
-  fetch: () => HttpServerResponse.text("ok"),
-});
+export default Worker.make(Layer.empty, Effect.succeed(HttpServerResponse.text("ok")));
 ```
 
 ## Durable Object Example
@@ -70,27 +69,30 @@ export const CounterDurableObject = Counter.make(Layer.empty, {
       }),
   },
 });
+
+export const CounterLayer = Counter.layer({ binding: "COUNTER" });
+
+export const readCounter = Effect.gen(function* () {
+  const counters = yield* Counter;
+  return yield* counters.byName("home").get();
+});
 ```
 
-Define Wrangler bindings and migrations in the consuming application.
+Define Wrangler bindings and migrations in the consuming application. Durable Object namespace bindings are provided with `YourObject.layer({ binding })`, and consumers use `const namespace = yield* YourObject`.
 
 ## Queue Example
 
-Queues use the same definition + binding split as Workers and Durable Objects: define the message contract once, use `.binding(...)` or `.Binding(...)` to produce from any runtime with `WorkerEnvironment`, and use `.make(...)` for the consumer Worker entrypoint.
+Queues define the message contract once. The same class is the producer service tag and the consumer Worker definition: use `YourQueue.layer({ binding })` to provide a Cloudflare producer binding from `WorkerEnvironment`, and use `.make(...)` for the consumer Worker entrypoint.
 
 ```ts
 import { Effect, Layer, Schema as S } from "effect";
 import { Queue } from "effect-cf";
 
-class AvatarJobs extends Queue.Tag<AvatarJobs>()("AvatarJobs", {
+class AvatarQueue extends Queue.Tag<AvatarQueue>()("AvatarQueue", {
   message: S.Struct({ userId: S.String, imageKey: S.String }),
 }) {}
 
-export const AvatarQueue = AvatarJobs.binding("AvatarQueue", {
-  binding: "AVATAR_QUEUE",
-});
-
-export const AvatarQueueConsumer = AvatarJobs.make(Layer.empty, {
+export const AvatarQueueConsumer = AvatarQueue.make(Layer.empty, {
   queue: (batch) =>
     Effect.gen(function* () {
       for (const message of batch.messages) {
@@ -99,9 +101,17 @@ export const AvatarQueueConsumer = AvatarJobs.make(Layer.empty, {
       }
     }),
 });
+
+export const AvatarQueueLayer = AvatarQueue.layer({ binding: "AVATAR_QUEUE" });
+
+export const enqueueAvatar = (userId: string, imageKey: string) =>
+  Effect.gen(function* () {
+    const queue = yield* AvatarQueue;
+    yield* queue.send({ userId, imageKey });
+  });
 ```
 
-Producers can use `AvatarQueue.send(...)`, `AvatarQueue.sendBatch(...)`, and `AvatarQueue.metrics` from any Worker, Durable Object, or Workflow layer that provides `WorkerEnvironment`.
+Producers should usually use `const queue = yield* AvatarQueue` and then call `queue.send(...)`, `queue.sendBatch(...)`, or `queue.metrics()`. The static `AvatarQueue.send(...)` helpers remain available for concise one-off calls.
 
 Queue handlers run inline failures through Cloudflare's normal retry path. If background work scheduled with `WorkerContext.waitUntil(...)` should also make the batch retry, use `WorkerContext.waitUntilPropagating(...)` or `waitUntil(..., { mode: "propagate" })`; the default `waitUntil` mode observes and logs failures without rejecting the native `waitUntil` promise.
 
@@ -130,12 +140,10 @@ export const ExportWorkflowEntrypoint = ExportWorkflow.make(Layer.empty, {
     }),
 });
 
-export const ExportWorkflowBinding = ExportWorkflow.binding("ExportWorkflow", {
-  binding: "EXPORT_WORKFLOW",
-});
+export const ExportWorkflowLayer = ExportWorkflow.layer({ binding: "EXPORT_WORKFLOW" });
 ```
 
-Use `ExportWorkflowBinding.create(...)`, `createBatch(...)`, and `get(...)` to start and inspect instances.
+Provide `ExportWorkflow.layer({ binding: "EXPORT_WORKFLOW" })`, then use `const workflow = yield* ExportWorkflow` or the static `ExportWorkflow.create(...)`, `createBatch(...)`, and `get(...)` helpers to start and inspect instances.
 
 In definition-backed workflows, the `payload` argument is the typed decoded payload and is the source of truth. `Workflow.WorkflowEvent.payload` is also re-provided decoded for convenience; `Workflow.WorkflowEvent.raw.payload` remains the native Cloudflare event payload.
 
@@ -187,24 +195,23 @@ export const RoomLive = DurableObject.make(layer, {
 
 Schema-backed attachments can rehydrate hibernated sockets:
 
-```ts
-const restored =
-  yield *
-  Attachments.rehydrate({
-    tag: "room:general",
-    onInvalid: "ignore-and-close",
-  });
+```text
+const restored = yield* Attachments.rehydrate({
+  tag: "room:general",
+  onInvalid: "ignore-and-close",
+});
 
 for (const { socket, attachment } of restored) {
-  yield * socket.send(`restored:${attachment.id}`).pipe(Effect.ignore);
+  yield* socket.send(`restored:${attachment.id}`).pipe(Effect.ignore);
 }
 ```
 
 Worker-to-Durable-Object forwarding should stay native so WebSocket upgrade responses are preserved:
 
-```ts
+```text
 if (Worker.isWebSocketUpgrade(request)) {
-  return yield * ChatRooms.byName(roomId).fetch(request);
+  const rooms = yield* ChatRoom;
+  return yield* rooms.byName(roomId).fetch(request);
 }
 ```