alchemy 2.0.0-beta.44 → 2.0.0-beta.45

package/lib/Cloudflare/Workers/RpcWorker.d.ts

@@ -0,0 +1,305 @@
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { type Rpc, RpcClient, type RpcGroup } from "effect/unstable/rpc";
+import type * as RpcClientError from "effect/unstable/rpc/RpcClientError";
+import type { Dependencies } from "../../Dependencies.ts";
+import type { HttpEffect } from "../../Http.ts";
+import type { Rpc as RpcShape } from "../../Rpc.ts";
+import type { Worker, WorkerProps } from "./Worker.ts";
+/**
+ * Props for {@link RpcWorker}. Same shape as {@link WorkerProps} with
+ * an additional `schema` field carrying the rpc group definition.
+ */
+export type RpcWorkerProps<Rpcs extends Rpc.Any> = Omit<WorkerProps, "schema"> & {
+    /**
+     * The {@link RpcGroup.RpcGroup} served on this worker's `fetch`
+     * handler. The same value should be importable by any consumer of
+     * the worker (other workers or scripts using `RpcClient.make`).
+     */
+    readonly schema: RpcGroup.RpcGroup<Rpcs>;
+};
+declare const RpcWorkerScope_base: Context.ServiceClass<RpcWorkerScope, "Cloudflare.RpcWorker", Worker>;
+export declare class RpcWorkerScope extends RpcWorkerScope_base {
+}
+declare const SchemaSymbol: unique symbol;
+export interface RpcWorkerYieldable<Self, Rpcs extends Rpc.Any, Deps = never> extends Effect.Effect<Worker<{}> & RpcShape<Self> & Dependencies<Deps>, never, any> {
+    /** @internal */
+    readonly [SchemaSymbol]: RpcGroup.RpcGroup<Rpcs>;
+}
+/**
+ * Type of the {@link RpcWorker} constructor. Mirrors the class-form
+ * signature of {@link Worker} so `class X extends RpcWorker<X>()(...)`
+ * works identically and the resulting worker is `Rpc<Self>`-typed for
+ * binding consumers.
+ */
+export interface RpcWorkerClass extends Effect.Effect<Worker, never, RpcWorkerScope> {
+    /**
+     * Class-based form: `class X extends RpcWorker<X>()(name, props, impl)`.
+     *
+     * The optional second type argument `Deps` mirrors
+     * `Cloudflare.Worker<Self, Bindings, Deps>` — it declares the DOs
+     * this Worker publishes for cross-script binding so consumers can
+     * write `Counter.from(WorkerA)` and have it type-check. `Rpcs` is
+     * always inferred from `props.schema`.
+     *
+     * Yielding the class in a Stack returns the {@link Worker} resource
+     * (so `worker.url`, `worker.workerName`, etc. work as usual). To get
+     * a typed `RpcClient` for *this* worker's rpc group from inside
+     * another worker's init, call {@link RpcWorker.bind}.
+     */
+    <Self, Deps = never>(): {
+        /**
+         * Modular form (no impl). Mirrors `Cloudflare.Worker<Self>()(id, props)`.
+         * Use `WorkerClass.make(impl)` to provide the runtime as a
+         * `Layer.Layer<Self>` so consumers that don't host the worker can
+         * import the class without pulling its runtime into their bundle.
+         */
+        <Rpcs extends Rpc.Any>(id: string, props: RpcWorkerProps<Rpcs>): RpcWorkerYieldable<Self, Rpcs, Deps> & {
+            new (_: never): {};
+            make<InnerR = never, InitReq = never>(impl: Effect.Effect<Effect.Effect<HttpEffect<InnerR>, never, InnerR>, never, InitReq>): Layer.Layer<Self, never, Exclude<InitReq | InnerR, never>>;
+        };
+        /** Inline-impl form. */
+        <Rpcs extends Rpc.Any, InnerR = never, InitReq = never>(id: string, props: RpcWorkerProps<Rpcs>, impl: Effect.Effect<Effect.Effect<HttpEffect<InnerR>, never, InnerR>, never, InitReq>): RpcWorkerYieldable<Self, Rpcs, Deps> & {
+            new (_: never): {};
+        };
+    };
+    /**
+     * Bind a typed Effect rpc client to a worker resource, using the
+     * worker's declared rpc {@link RpcGroup.RpcGroup} schema. Mirrors
+     * `Cloudflare.R2Bucket.bind(MyBucket)` and friends.
+     *
+     * Yield once at **init** — the result is a normal `RpcClient` you
+     * can call directly from any per-request handler. Internally each
+     * method invocation builds a fresh underlying `RpcClient` (through
+     * a Proxy) because Cloudflare rejects I/O objects created on a
+     * previous request; this is hidden from the consumer.
+     *
+     * Pair with {@link RpcWorker} on the server side; both ends share
+     * the same schema so values round-trip through one `Schema` codec.
+     *
+     * @example
+     * ```ts
+     * // INIT: register the binding once and get the typed client
+     * const tasks = yield* Cloudflare.RpcWorker.bind(TaskWorker);
+     *
+     * // PER-REQUEST: call methods directly
+     * proxyGetTask: ({ id }) => tasks.getTask({ id }),
+     * ```
+     */
+    readonly bind: <Self, Rpcs extends Rpc.Any>(workerEff: RpcWorkerYieldable<Self, Rpcs>) => Effect.Effect<RpcClient.RpcClient<Rpcs, RpcClientError.RpcClientError> & RpcShape<Self>, never, Worker>;
+}
+/**
+ * `RpcWorker` is a thin sugar over {@link Worker} for the common case
+ * where a worker's entire `fetch` surface is a typed Effect `RpcGroup`.
+ * It takes the rpc `schema` directly in props alongside `main`, and
+ * accepts an init Effect that returns the already-piped
+ * `RpcServer.toHttpEffect(...)`-producing Effect (no `{ fetch }`
+ * wrapper) — the wrapper plugs it into the worker's `fetch` for you.
+ *
+ * Functionally identical to writing `Cloudflare.Worker(...)` with
+ * `return { fetch: RpcServer.toHttpEffect(schema).pipe(...) }`; use
+ * whichever style you prefer.
+ *
+ * The class form (`class X extends Cloudflare.RpcWorker<X>()(...)`)
+ * carries `Self` through the result type as `Rpc<Self>`, so other
+ * workers binding to this one see the rpc shape pinned to `Self`.
+ *
+ * @resource
+ *
+ * @section Defining the rpc group
+ * @example Pure schema description
+ * The rpc group and its schemas live outside any worker so both the
+ * server (`RpcWorker`) and any consumers (`RpcClient.make` /
+ * `RpcDurableObjectNamespace`) import the same value.
+ * ```typescript
+ * import * as Schema from "effect/Schema";
+ * import { Rpc, RpcGroup } from "effect/unstable/rpc";
+ *
+ * export class TaskNotFound extends Schema.TaggedClass<TaskNotFound>()(
+ *   "TaskNotFound",
+ *   { id: Schema.String },
+ * ) {}
+ *
+ * const getTask = Rpc.make("getTask", {
+ *   payload: { id: Schema.String },
+ *   success: Schema.String,
+ *   error: TaskNotFound,
+ * });
+ *
+ * export class TaskRpcs extends RpcGroup.make(getTask) {}
+ * ```
+ *
+ * @section Implementing the worker
+ * @example Class form (recommended)
+ * Mirrors `Cloudflare.Worker<Self>()(...)` — `class X extends ...`
+ * works the same. The init Effect builds a handlers `Layer` from the
+ * group and returns the `RpcServer.toHttpEffect(schema)`-piped Effect
+ * directly.
+ * ```typescript
+ * import * as Cloudflare from "alchemy/Cloudflare";
+ * import * as Effect from "effect/Effect";
+ * import * as Layer from "effect/Layer";
+ * import { RpcSerialization, RpcServer } from "effect/unstable/rpc";
+ * import { TaskRpcs } from "./rpcs.ts";
+ *
+ * export default class Worker extends Cloudflare.RpcWorker<Worker>()(
+ *   "Worker",
+ *   { main: import.meta.filename, schema: TaskRpcs },
+ *   Effect.gen(function* () {
+ *     const handlers = TaskRpcs.toLayer({
+ *       getTask: ({ id }) => Effect.succeed(`task-${id}`),
+ *     });
+ *     return RpcServer.toHttpEffect(TaskRpcs).pipe(
+ *       Effect.provide(Layer.mergeAll(handlers, RpcSerialization.layerJson)),
+ *     );
+ *   }),
+ * ) {}
+ * ```
+ *
+ * @example NDJSON for streaming rpcs
+ * If any rpc in the group is a streaming rpc, the wire serialization
+ * must be `RpcSerialization.layerNdjson` — streaming rpcs need
+ * newline framing on the wire.
+ * ```typescript
+ * return RpcServer.toHttpEffect(ChatRpcs).pipe(
+ *   Effect.provide(handlers),
+ *   Effect.provide(RpcSerialization.layerNdjson),
+ * );
+ * ```
+ *
+ * @section Modular form: separate the class from its runtime
+ * @example Class declaration with no impl + `static make(impl)`
+ * The inline class form above bundles the runtime into the class
+ * declaration. The two-arg form `(id, props)` declares the class
+ * as a pure tagged identifier; provide the runtime separately via
+ * `WorkerClass.make(impl)` so consumers can import the class for
+ * binding without pulling the host's runtime into their bundle.
+ * ```typescript
+ * export class TaskWorker extends Cloudflare.RpcWorker<TaskWorker>()(
+ *   "TaskWorker",
+ *   { main: import.meta.filename, schema: TaskRpcs },
+ * ) {}
+ *
+ * // Only the host script imports this default export; consumers
+ * // import the class above for `RpcWorker.bind(TaskWorker)`.
+ * export default TaskWorker.make(
+ *   Effect.gen(function* () {
+ *     const handlers = TaskRpcs.toLayer({
+ *       getTask: ({ id }) => Effect.succeed(`task-${id}`),
+ *     });
+ *     return RpcServer.toHttpEffect(TaskRpcs).pipe(
+ *       Effect.provide(Layer.mergeAll(handlers, RpcSerialization.layerJson)),
+ *     );
+ *   }),
+ * );
+ * ```
+ *
+ * @section Hosting a Durable Object for cross-script binding
+ * @example `RpcWorker<Self, Deps>()` declares published DOs
+ * The optional second type argument `Deps` mirrors
+ * `Cloudflare.Worker<Self, Bindings, Deps>` — it declares the DOs
+ * this Worker publishes for cross-script binding. With `Counter`
+ * named in `Deps`, any other Worker can write
+ * `Counter.from(TaskWorker)` and have it type-check.
+ * ```typescript
+ * import { Counter } from "./counter.ts";
+ *
+ * export class TaskWorker extends Cloudflare.RpcWorker<TaskWorker, Counter>()(
+ *   "TaskWorker",
+ *   { main: import.meta.filename, schema: TaskRpcs },
+ * ) {}
+ * ```
+ * See {@link RpcDurableObjectNamespace} for the consumer side
+ * (`Counter.from(TaskWorker)`).
+ *
+ * @section Binding it from another worker
+ * @example `Cloudflare.RpcWorker.bind(WorkerClass)`
+ * Inside another worker's init, `RpcWorker.bind(WorkerClass)`
+ * registers the service binding on the surrounding worker and returns
+ * a typed `RpcClient` you can call directly from any per-request
+ * handler. Internally each method invocation builds a fresh underlying
+ * client (because Cloudflare rejects cross-request reuse of the
+ * stub I/O), but that's hidden behind a Proxy so the consumer sees a
+ * normal `RpcClient`.
+ * ```typescript
+ * import TaskWorker from "./task-worker.ts";
+ *
+ * export default class Caller extends Cloudflare.RpcWorker<Caller>()(
+ *   "Caller",
+ *   { main: import.meta.filename, schema: CallerRpcs },
+ *   Effect.gen(function* () {
+ *     // INIT: register binding, get the typed client
+ *     const tasks = yield* Cloudflare.RpcWorker.bind(TaskWorker);
+ *
+ *     const handlers = CallerRpcs.toLayer({
+ *       // PER-REQUEST: just call methods directly
+ *       proxyGetTask: ({ id }) => tasks.getTask({ id }),
+ *     });
+ *     return RpcServer.toHttpEffect(CallerRpcs).pipe(
+ *       Effect.provide(Layer.mergeAll(handlers, RpcSerialization.layerJson)),
+ *     );
+ *   }),
+ * ) {}
+ * ```
+ *
+ * @section Driving it from a test
+ * @example `Test.make` + `RpcClient.make`
+ * The same `RpcGroup` drives a typed client. `Test.make` deploys the
+ * stack once for the file; each test yields the deploy handle for its
+ * URL and calls procedures directly.
+ * ```typescript
+ * import { expect } from "@effect/vitest";
+ * import * as Cloudflare from "alchemy/Cloudflare";
+ * import * as Test from "alchemy/Test/Vitest";
+ * import * as Effect from "effect/Effect";
+ * import * as Layer from "effect/Layer";
+ * import * as Schedule from "effect/Schedule";
+ * import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
+ * import * as RpcClient from "effect/unstable/rpc/RpcClient";
+ * import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization";
+ * import Stack from "../alchemy.run.ts";
+ * import { TaskRpcs } from "../src/rpcs.ts";
+ *
+ * const { test, beforeAll, afterAll, deploy, destroy } = Test.make({
+ *   providers: Cloudflare.providers(),
+ * });
+ * const stack = beforeAll(deploy(Stack));
+ * afterAll.skipIf(!!process.env.NO_DESTROY)(destroy(Stack));
+ *
+ * const layer = (url: string) =>
+ *   RpcClient.layerProtocolHttp({ url }).pipe(
+ *     Layer.provide(FetchHttpClient.layer),
+ *     Layer.provide(
+ *       Layer.succeed(RpcSerialization.RpcSerialization, RpcSerialization.json),
+ *     ),
+ *   );
+ *
+ * test(
+ *   "getTask",
+ *   Effect.gen(function* () {
+ *     const { url } = yield* stack;
+ *     yield* Effect.gen(function* () {
+ *       const client = yield* RpcClient.make(TaskRpcs);
+ *       const result = yield* client
+ *         .getTask({ id: "abc" })
+ *         .pipe(Effect.retry({ schedule: Schedule.exponential("500 millis"), times: 5 }));
+ *       expect(result).toBe("task-abc");
+ *     }).pipe(Effect.scoped, Effect.provide(layer(url)));
+ *   }),
+ * );
+ * ```
+ *
+ * @section Yielding the surrounding worker from inside the impl
+ * @example `yield* RpcWorker` inside the init effect
+ * Mirrors `yield* DurableObjectNamespace` — yield the tag to access
+ * the surrounding worker.
+ * ```typescript
+ * Effect.gen(function* () {
+ *   const self = yield* Cloudflare.RpcWorker;
+ * });
+ * ```
+ */
+export declare const RpcWorker: RpcWorkerClass;
+export {};
+//# sourceMappingURL=RpcWorker.d.ts.map

package/lib/Cloudflare/Workers/RpcWorker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RpcWorker.d.ts","sourceRoot":"","sources":["../../../src/Cloudflare/Workers/RpcWorker.ts"],"names":[],"mappings":"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"}

package/lib/Cloudflare/Workers/RpcWorker.js

@@ -0,0 +1,350 @@
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as HttpClient from "effect/unstable/http/HttpClient";
+import * as HttpClientResponse from "effect/unstable/http/HttpClientResponse";
+import { RpcClient, RpcSerialization, } from "effect/unstable/rpc";
+import { effectClass, taggedFunction } from "../../Util/effect.js";
+import { Worker as WorkerCtor, WorkerEnvironment } from "./Worker.js";
+// Context tag carrying the surrounding `RpcWorker` value, so
+// `yield* RpcWorker` inside the impl resolves to the worker itself
+// (mirrors `yield* Worker` semantics inside `Cloudflare.Worker`).
+// Documented as part of the main `RpcWorker` JSDoc below.
+export class RpcWorkerScope extends Context.Service()("Cloudflare.RpcWorker") {
+}
+// Symbol used internally to stash the rpc `RpcGroup` schema on the
+// `effectClass` that `RpcWorker(...)` returns, so `RpcWorker.bind`
+// can recover it when handed the class later.
+const SchemaSymbol = Symbol.for("alchemy.RpcWorker.schema");
+/** @internal helper — exposed as `RpcWorker.bind` below. */
+const bind = (workerEff) => Effect.gen(function* () {
+    const schema = workerEff[SchemaSymbol];
+    if (!schema) {
+        return yield* Effect.die(new Error("RpcWorker.bind: passed value isn't an RpcWorker class — no schema attached."));
+    }
+    const worker = (yield* workerEff);
+    // Register the service binding on the surrounding worker at INIT.
+    // Mirrors `Cloudflare.bindWorker` — yielding the class is *not*
+    // enough; we need an explicit `self.bind\`${worker}\`(...)` so
+    // workerd surfaces the stub on `env` at request time.
+    const self = yield* WorkerCtor;
+    yield* self.bind `${worker}`({
+        bindings: [
+            {
+                type: "service",
+                name: worker.LogicalId,
+                service: worker.workerName,
+            },
+        ],
+    });
+    // Build a per-call factory that wraps the Cloudflare service-
+    // binding stub (Promise-based fetch) into an Effect `HttpClient`,
+    // then `RpcClient.make` over that transport. Each call gets its
+    // own `RpcClient` because Cloudflare rejects I/O objects (the
+    // stub.fetch body) that were created on a previous request.
+    const makeFreshClient = Effect.gen(function* () {
+        const env = yield* WorkerEnvironment;
+        const stub = env[worker.LogicalId];
+        const httpClient = HttpClient.make((req) => Effect.promise((signal) => stub.fetch(new Request(req.url, {
+            method: req.method,
+            headers: new Headers(req.headers),
+            body: req.body?.body ?? undefined,
+            signal,
+        }))).pipe(Effect.map((res) => HttpClientResponse.fromWeb(req, res))));
+        const protocol = RpcClient.layerProtocolHttp({
+            url: "http://alchemy-rpc-worker/",
+        }).pipe(Layer.provide(RpcSerialization.layerNdjson), Layer.provide(Layer.succeed(HttpClient.HttpClient, httpClient)));
+        return yield* RpcClient.make(schema).pipe(Effect.provide(protocol));
+    });
+    // Return a Proxy that LOOKS like an `RpcClient<Rpcs>` but defers
+    // the actual `RpcClient` construction to call time. Mirrors
+    // `makeRpcStub` from `./Rpc.ts`: each method invocation builds a
+    // fresh client, runs the call inside `Effect.scoped`, and tears
+    // the client's scope down with the call. From the consumer's
+    // perspective this is a normal `RpcClient`:
+    //
+    //   const tasks = yield* Cloudflare.RpcWorker.bind(TaskWorker);
+    //   yield* tasks.getTask({ id: "abc" });
+    return new Proxy({}, {
+        get: (_target, method) => {
+            if (typeof method !== "string")
+                return undefined;
+            return (...args) => Effect.gen(function* () {
+                const client = yield* makeFreshClient;
+                const fn = client[method];
+                return yield* fn(...args);
+            }).pipe(Effect.scoped);
+        },
+    });
+});
+/**
+ * `RpcWorker` is a thin sugar over {@link Worker} for the common case
+ * where a worker's entire `fetch` surface is a typed Effect `RpcGroup`.
+ * It takes the rpc `schema` directly in props alongside `main`, and
+ * accepts an init Effect that returns the already-piped
+ * `RpcServer.toHttpEffect(...)`-producing Effect (no `{ fetch }`
+ * wrapper) — the wrapper plugs it into the worker's `fetch` for you.
+ *
+ * Functionally identical to writing `Cloudflare.Worker(...)` with
+ * `return { fetch: RpcServer.toHttpEffect(schema).pipe(...) }`; use
+ * whichever style you prefer.
+ *
+ * The class form (`class X extends Cloudflare.RpcWorker<X>()(...)`)
+ * carries `Self` through the result type as `Rpc<Self>`, so other
+ * workers binding to this one see the rpc shape pinned to `Self`.
+ *
+ * @resource
+ *
+ * @section Defining the rpc group
+ * @example Pure schema description
+ * The rpc group and its schemas live outside any worker so both the
+ * server (`RpcWorker`) and any consumers (`RpcClient.make` /
+ * `RpcDurableObjectNamespace`) import the same value.
+ * ```typescript
+ * import * as Schema from "effect/Schema";
+ * import { Rpc, RpcGroup } from "effect/unstable/rpc";
+ *
+ * export class TaskNotFound extends Schema.TaggedClass<TaskNotFound>()(
+ *   "TaskNotFound",
+ *   { id: Schema.String },
+ * ) {}
+ *
+ * const getTask = Rpc.make("getTask", {
+ *   payload: { id: Schema.String },
+ *   success: Schema.String,
+ *   error: TaskNotFound,
+ * });
+ *
+ * export class TaskRpcs extends RpcGroup.make(getTask) {}
+ * ```
+ *
+ * @section Implementing the worker
+ * @example Class form (recommended)
+ * Mirrors `Cloudflare.Worker<Self>()(...)` — `class X extends ...`
+ * works the same. The init Effect builds a handlers `Layer` from the
+ * group and returns the `RpcServer.toHttpEffect(schema)`-piped Effect
+ * directly.
+ * ```typescript
+ * import * as Cloudflare from "alchemy/Cloudflare";
+ * import * as Effect from "effect/Effect";
+ * import * as Layer from "effect/Layer";
+ * import { RpcSerialization, RpcServer } from "effect/unstable/rpc";
+ * import { TaskRpcs } from "./rpcs.ts";
+ *
+ * export default class Worker extends Cloudflare.RpcWorker<Worker>()(
+ *   "Worker",
+ *   { main: import.meta.filename, schema: TaskRpcs },
+ *   Effect.gen(function* () {
+ *     const handlers = TaskRpcs.toLayer({
+ *       getTask: ({ id }) => Effect.succeed(`task-${id}`),
+ *     });
+ *     return RpcServer.toHttpEffect(TaskRpcs).pipe(
+ *       Effect.provide(Layer.mergeAll(handlers, RpcSerialization.layerJson)),
+ *     );
+ *   }),
+ * ) {}
+ * ```
+ *
+ * @example NDJSON for streaming rpcs
+ * If any rpc in the group is a streaming rpc, the wire serialization
+ * must be `RpcSerialization.layerNdjson` — streaming rpcs need
+ * newline framing on the wire.
+ * ```typescript
+ * return RpcServer.toHttpEffect(ChatRpcs).pipe(
+ *   Effect.provide(handlers),
+ *   Effect.provide(RpcSerialization.layerNdjson),
+ * );
+ * ```
+ *
+ * @section Modular form: separate the class from its runtime
+ * @example Class declaration with no impl + `static make(impl)`
+ * The inline class form above bundles the runtime into the class
+ * declaration. The two-arg form `(id, props)` declares the class
+ * as a pure tagged identifier; provide the runtime separately via
+ * `WorkerClass.make(impl)` so consumers can import the class for
+ * binding without pulling the host's runtime into their bundle.
+ * ```typescript
+ * export class TaskWorker extends Cloudflare.RpcWorker<TaskWorker>()(
+ *   "TaskWorker",
+ *   { main: import.meta.filename, schema: TaskRpcs },
+ * ) {}
+ *
+ * // Only the host script imports this default export; consumers
+ * // import the class above for `RpcWorker.bind(TaskWorker)`.
+ * export default TaskWorker.make(
+ *   Effect.gen(function* () {
+ *     const handlers = TaskRpcs.toLayer({
+ *       getTask: ({ id }) => Effect.succeed(`task-${id}`),
+ *     });
+ *     return RpcServer.toHttpEffect(TaskRpcs).pipe(
+ *       Effect.provide(Layer.mergeAll(handlers, RpcSerialization.layerJson)),
+ *     );
+ *   }),
+ * );
+ * ```
+ *
+ * @section Hosting a Durable Object for cross-script binding
+ * @example `RpcWorker<Self, Deps>()` declares published DOs
+ * The optional second type argument `Deps` mirrors
+ * `Cloudflare.Worker<Self, Bindings, Deps>` — it declares the DOs
+ * this Worker publishes for cross-script binding. With `Counter`
+ * named in `Deps`, any other Worker can write
+ * `Counter.from(TaskWorker)` and have it type-check.
+ * ```typescript
+ * import { Counter } from "./counter.ts";
+ *
+ * export class TaskWorker extends Cloudflare.RpcWorker<TaskWorker, Counter>()(
+ *   "TaskWorker",
+ *   { main: import.meta.filename, schema: TaskRpcs },
+ * ) {}
+ * ```
+ * See {@link RpcDurableObjectNamespace} for the consumer side
+ * (`Counter.from(TaskWorker)`).
+ *
+ * @section Binding it from another worker
+ * @example `Cloudflare.RpcWorker.bind(WorkerClass)`
+ * Inside another worker's init, `RpcWorker.bind(WorkerClass)`
+ * registers the service binding on the surrounding worker and returns
+ * a typed `RpcClient` you can call directly from any per-request
+ * handler. Internally each method invocation builds a fresh underlying
+ * client (because Cloudflare rejects cross-request reuse of the
+ * stub I/O), but that's hidden behind a Proxy so the consumer sees a
+ * normal `RpcClient`.
+ * ```typescript
+ * import TaskWorker from "./task-worker.ts";
+ *
+ * export default class Caller extends Cloudflare.RpcWorker<Caller>()(
+ *   "Caller",
+ *   { main: import.meta.filename, schema: CallerRpcs },
+ *   Effect.gen(function* () {
+ *     // INIT: register binding, get the typed client
+ *     const tasks = yield* Cloudflare.RpcWorker.bind(TaskWorker);
+ *
+ *     const handlers = CallerRpcs.toLayer({
+ *       // PER-REQUEST: just call methods directly
+ *       proxyGetTask: ({ id }) => tasks.getTask({ id }),
+ *     });
+ *     return RpcServer.toHttpEffect(CallerRpcs).pipe(
+ *       Effect.provide(Layer.mergeAll(handlers, RpcSerialization.layerJson)),
+ *     );
+ *   }),
+ * ) {}
+ * ```
+ *
+ * @section Driving it from a test
+ * @example `Test.make` + `RpcClient.make`
+ * The same `RpcGroup` drives a typed client. `Test.make` deploys the
+ * stack once for the file; each test yields the deploy handle for its
+ * URL and calls procedures directly.
+ * ```typescript
+ * import { expect } from "@effect/vitest";
+ * import * as Cloudflare from "alchemy/Cloudflare";
+ * import * as Test from "alchemy/Test/Vitest";
+ * import * as Effect from "effect/Effect";
+ * import * as Layer from "effect/Layer";
+ * import * as Schedule from "effect/Schedule";
+ * import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
+ * import * as RpcClient from "effect/unstable/rpc/RpcClient";
+ * import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization";
+ * import Stack from "../alchemy.run.ts";
+ * import { TaskRpcs } from "../src/rpcs.ts";
+ *
+ * const { test, beforeAll, afterAll, deploy, destroy } = Test.make({
+ *   providers: Cloudflare.providers(),
+ * });
+ * const stack = beforeAll(deploy(Stack));
+ * afterAll.skipIf(!!process.env.NO_DESTROY)(destroy(Stack));
+ *
+ * const layer = (url: string) =>
+ *   RpcClient.layerProtocolHttp({ url }).pipe(
+ *     Layer.provide(FetchHttpClient.layer),
+ *     Layer.provide(
+ *       Layer.succeed(RpcSerialization.RpcSerialization, RpcSerialization.json),
+ *     ),
+ *   );
+ *
+ * test(
+ *   "getTask",
+ *   Effect.gen(function* () {
+ *     const { url } = yield* stack;
+ *     yield* Effect.gen(function* () {
+ *       const client = yield* RpcClient.make(TaskRpcs);
+ *       const result = yield* client
+ *         .getTask({ id: "abc" })
+ *         .pipe(Effect.retry({ schedule: Schedule.exponential("500 millis"), times: 5 }));
+ *       expect(result).toBe("task-abc");
+ *     }).pipe(Effect.scoped, Effect.provide(layer(url)));
+ *   }),
+ * );
+ * ```
+ *
+ * @section Yielding the surrounding worker from inside the impl
+ * @example `yield* RpcWorker` inside the init effect
+ * Mirrors `yield* DurableObjectNamespace` — yield the tag to access
+ * the surrounding worker.
+ * ```typescript
+ * Effect.gen(function* () {
+ *   const self = yield* Cloudflare.RpcWorker;
+ * });
+ * ```
+ */
+export const RpcWorker = (() => {
+    const fn = (...args) => {
+        // Class-form: zero args returns the inner builder. Inner-arg arity
+        // distinguishes modular (`(id, props)`, no impl — `static make(impl)`
+        // provides the runtime) from inline-impl (`(id, props, impl)`).
+        if (args.length === 0) {
+            return (...inner) => {
+                if (inner.length === 2) {
+                    const [id, props] = inner;
+                    return buildModular(id, props);
+                }
+                const [id, props, impl] = inner;
+                return build(id, props, impl);
+            };
+        }
+        // Bare form: `(name, props, impl)`.
+        const [id, props, impl] = args;
+        return build(id, props, impl);
+    };
+    const tagged = taggedFunction(RpcWorkerScope, fn);
+    tagged.bind = bind;
+    return tagged;
+})();
+const wrapImpl = (impl) => 
+// The user's inner Effect resolves to `HttpEffect`; the underlying
+// `Cloudflare.Worker` expects `{ fetch: HttpEffect }`. Box it.
+Effect.map(impl, (fetch) => ({ fetch }));
+const buildModular = (id, props) => {
+    const { schema, ...workerProps } = props;
+    // Delegate to `Cloudflare.Worker<Self>()(id, props)` (modular form)
+    // so we inherit its `static make(impl)` plumbing for free. We just
+    // wrap the user's HttpEffect-returning impl into the `{ fetch }`
+    // shape `Cloudflare.Worker` expects, and stash the rpc schema on
+    // the class so `RpcWorker.bind(WorkerClass)` can recover it.
+    const Underlying = WorkerCtor()(id, workerProps);
+    const klass = class extends effectClass(Underlying.asEffect()) {
+        static make = (impl) => Underlying.make(wrapImpl(impl));
+    };
+    klass[SchemaSymbol] = schema;
+    return klass;
+};
+const build = (id, props, impl) => {
+    const { schema, ...workerProps } = props;
+    // Wrap the user's HttpEffect-returning Effect into the `{ fetch }`
+    // shape `Cloudflare.Worker` expects.
+    const wrappedImpl = Effect.map(impl, (fetch) => ({ fetch }));
+    // Delegate registration / binding metadata to the underlying
+    // `Cloudflare.Worker`. The returned `effectClass`, when yielded,
+    // produces the standard `Worker` resource (so `worker.url`,
+    // `worker.workerName`, etc. all work as usual).
+    const underlying = WorkerCtor()(id, workerProps, wrappedImpl);
+    // Re-wrap as our own `effectClass` so we can stash the rpc schema
+    // on the class for `RpcWorker.bind` to recover later. (Re-using
+    // `effectClass` here means `class X extends RpcWorker<X>()(...)`
+    // still works.)
+    const klass = effectClass(underlying.asEffect());
+    klass[SchemaSymbol] = schema;
+    return klass;
+};
+//# sourceMappingURL=RpcWorker.js.map

package/lib/Cloudflare/Workers/RpcWorker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RpcWorker.js","sourceRoot":"","sources":["../../../src/Cloudflare/Workers/RpcWorker.ts"],"names":[],"mappings":"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"}