effect-cf 0.0.1

package/src/ServiceBinding.ts

@@ -0,0 +1,278 @@
+import { Data, Effect } from "effect";
+
+import * as Binding from "./Binding";
+import * as CloudflareRpc from "./Rpc";
+import * as RpcDefinition from "./RpcDefinition";
+import type * as WorkerDefinition from "./WorkerDefinition";
+import * as RpcInvocation from "./internal/RpcInvocation";
+
+const TypeId = "effect-cf/ServiceBinding" as const;
+
+/**
+ * Minimum shape for a Cloudflare service binding.
+ */
+export interface ServiceFetcher {
+  fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
+}
+
+type RpcClient<Api> = {
+  readonly [Key in keyof Api as Key extends string
+    ? Api[Key] extends (...args: Array<any>) => unknown
+      ? Key
+      : never
+    : never]: Api[Key];
+};
+
+type ReservedMethodName = WorkerDefinition.ReservedMethodName | "fetch";
+
+/**
+ * Native Cloudflare service object including optional RPC methods.
+ */
+export type ServiceBindingClient<Api extends object> = ServiceFetcher &
+  RpcClient<CloudflareRpc.Provider<Api, ReservedMethodName>>;
+
+type ApiFromDefinition<Definition> = Definition extends WorkerDefinition.Definition.Any
+  ? WorkerDefinition.ServerApi<Definition>
+  : never;
+
+type ApiOrDefinition<Api extends object, Definition> = [Api] extends [never]
+  ? ApiFromDefinition<Definition>
+  : Api;
+
+/**
+ * Binding metadata used to create an Effect service from a Worker binding.
+ */
+export interface ServiceBindingDefinition<
+  Definition extends WorkerDefinition.Definition.Any | undefined = undefined,
+> {
+  /** Binding name as configured in `wrangler.jsonc`. */
+  readonly binding: string;
+  /** Optional RPC schema used for argument/result encoding. */
+  readonly definition?: Definition;
+}
+
+/**
+ * Failure raised when calling `fetch` on a service binding.
+ */
+export class ServiceBindingFetchError extends Data.TaggedError("ServiceBindingFetchError")<{
+  readonly binding: string;
+  readonly cause: unknown;
+}> {}
+
+/**
+ * Failure raised when invoking an RPC method on a service binding.
+ */
+export class ServiceBindingRpcError extends Data.TaggedError("ServiceBindingRpcError")<{
+  readonly binding: string;
+  readonly method: string;
+  readonly cause: unknown;
+}> {}
+
+type ServiceMethodKey<Api> = RpcInvocation.AsyncMethodKey<Api>;
+type ServiceMethodArgs<Api, Method extends keyof Api> = RpcInvocation.AsyncMethodArgs<Api, Method>;
+type ServiceMethodSuccess<Api, Method extends keyof Api> = RpcInvocation.AsyncMethodSuccess<
+  Api,
+  Method
+>;
+
+type ServiceCall<Self, Api> = <Method extends ServiceMethodKey<Api>>(
+  method: Method,
+  ...args: ServiceMethodArgs<Api, Method>
+) => Effect.Effect<ServiceMethodSuccess<Api, Method>, ServiceBindingRpcError, Self>;
+
+type DefinitionDirectMethods<Self, 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
+  >;
+};
+
+type DirectMethods<Self, Definition> = Definition extends WorkerDefinition.Definition.Any
+  ? DefinitionDirectMethods<Self, Definition>
+  : {};
+
+/**
+ * Creates a typed Effect service for a Worker service binding.
+ *
+ * Returned value includes:
+ * - a Context tag for dependency injection
+ * - `fetch(...)` for raw HTTP forwarding
+ * - `call(...)` for generic RPC invocation
+ * - direct RPC methods when `definition` is provided
+ *
+ * @example
+ * ```ts
+ * const Counter = WorkerDefinition.make("Counter", {
+ *   increment: WorkerDefinition.method({
+ *     args: [Schema.Number],
+ *     success: Schema.Number,
+ *   }),
+ * });
+ *
+ * const CounterService = Counter.binding("COUNTER", { binding: "COUNTER" });
+ *
+ * const program = Effect.gen(function* () {
+ *   const next = yield* CounterService.increment(1);
+ *   return next;
+ * });
+ * ```
+ */
+export const Service =
+  <Self, Api extends object = never>() =>
+  <
+    Id extends string,
+    const Definition extends WorkerDefinition.Definition.Any | undefined = undefined,
+  >(
+    id: Id,
+    definition: ServiceBindingDefinition<Definition>,
+  ) => {
+    type ServiceApi = ApiOrDefinition<Api, Definition>;
+
+    const tag = Binding.Service<Self>()(
+      id,
+      definition.binding,
+      (value): value is ServiceBindingClient<ServiceApi> =>
+        typeof value === "object" && value !== null && "fetch" in value,
+    );
+
+    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 }),
+        });
+      });
+
+    const rpc = <Method extends ServiceMethodKey<ServiceApi>>(
+      method: Method,
+      ...args: ServiceMethodArgs<ServiceApi, Method>
+    ) =>
+      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,
+            }),
+        );
+      });
+
+    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<Self, ServiceApi, Definition>(
+      definition.definition,
+      call,
+    );
+
+    return Object.assign(tag, directMethods, {
+      [TypeId]: TypeId,
+      definition,
+      fetch,
+      rpc,
+      call,
+      scopedCall,
+    }) as typeof tag &
+      DirectMethods<Self, Definition> & {
+        readonly [TypeId]: typeof TypeId;
+        readonly definition: ServiceBindingDefinition<Definition>;
+        readonly fetch: typeof fetch;
+        readonly rpc: typeof rpc;
+        readonly call: typeof call;
+        readonly scopedCall: typeof scopedCall;
+      };
+  };
+
+const makeDirectMethods = <
+  Self,
+  Api,
+  Definition extends WorkerDefinition.Definition.Any | undefined,
+>(
+  rpcDefinition: Definition | undefined,
+  call: ServiceCall<Self, Api>,
+): DirectMethods<Self, Definition> => {
+  const methods = {} as Record<string, unknown>;
+
+  if (rpcDefinition !== undefined) {
+    for (const methodName of Object.keys(rpcDefinition.methods)) {
+      methods[methodName] = (...args: Array<unknown>) =>
+        (call as (method: string, ...args: Array<unknown>) => unknown)(methodName, ...args);
+    }
+  }
+
+  return methods as DirectMethods<Self, Definition>;
+};

package/src/Worker.ts

@@ -0,0 +1,264 @@
+import { WorkerEntrypoint as CloudflareWorkerEntrypoint } from "cloudflare:workers";
+import { Cause, Context, Effect, Exit, Layer, ManagedRuntime, type Scope } from "effect";
+import { HttpServerRequest } from "effect/unstable/http";
+
+import { WorkerEnvironment, type WorkerEnv } from "./Environment";
+import type * as RpcDefinition from "./RpcDefinition";
+import * as WorkerDefinition from "./WorkerDefinition";
+import * as Entrypoint from "./internal/Entrypoint";
+
+export class ExecutionContext extends Context.Service<
+  ExecutionContext,
+  globalThis.ExecutionContext
+>()("effect-cf/ExecutionContext") {}
+
+export interface WorkerContextWaitUntilOptions<E, R> {
+  readonly onFailure?: (cause: Cause.Cause<E>) => Effect.Effect<void, never, R>;
+}
+
+export interface WorkerContextService {
+  readonly raw: globalThis.ExecutionContext;
+  waitUntil<A, E, R, R2 = never>(
+    effect: Effect.Effect<A, E, R>,
+    options?: WorkerContextWaitUntilOptions<E, R2>,
+  ): Effect.Effect<void, never, R | R2>;
+  readonly passThroughOnException: Effect.Effect<void>;
+}
+
+export class WorkerContext extends Context.Service<WorkerContext, WorkerContextService>()(
+  "effect-cf/WorkerContext",
+) {}
+
+type RunWaitUntilEffect = <A, E>(
+  effect: Effect.Effect<A, E, never>,
+) => Promise<Exit.Exit<A, unknown>>;
+
+const fromExecutionContext = (
+  ctx: globalThis.ExecutionContext,
+  runPromiseExit: RunWaitUntilEffect,
+): WorkerContextService => ({
+  raw: ctx,
+  waitUntil: <A, E, R, R2 = never>(
+    effect: Effect.Effect<A, E, R>,
+    options?: WorkerContextWaitUntilOptions<E, R2>,
+  ) =>
+    Effect.context<R | R2>().pipe(
+      Effect.flatMap((context) =>
+        Effect.sync(() => {
+          const observed = Effect.exit(effect).pipe(
+            Effect.flatMap((exit) => {
+              if (Exit.isSuccess(exit)) {
+                return Effect.void;
+              }
+
+              const handleFailure =
+                options?.onFailure?.(exit.cause) ??
+                Effect.logError("WorkerContext.waitUntil failed", Cause.pretty(exit.cause));
+
+              return handleFailure.pipe(
+                Effect.catchCause((handlerCause) =>
+                  Effect.logError(
+                    "WorkerContext.waitUntil failure handler failed",
+                    Cause.pretty(exit.cause),
+                    Cause.pretty(handlerCause),
+                  ),
+                ),
+              );
+            }),
+          );
+
+          ctx.waitUntil(
+            runPromiseExit(Effect.scoped(Effect.provideContext(observed, context))).then((exit) => {
+              if (Exit.isFailure(exit)) {
+                console.error(
+                  "WorkerContext.waitUntil failure handler failed",
+                  Cause.pretty(exit.cause),
+                );
+              }
+            }),
+          );
+        }),
+      ),
+    ),
+  passThroughOnException: Effect.sync(() => ctx.passThroughOnException()),
+});
+
+export class NativeRequest extends Context.Service<NativeRequest, Request>()(
+  "effect-cf/NativeRequest",
+) {}
+
+export const isWebSocketUpgrade = (request: Request): boolean =>
+  request.headers.get("Upgrade")?.toLowerCase() === "websocket";
+
+export type ReservedMethodName =
+  | RpcDefinition.ReservedMethodName
+  | "fetch"
+  | "connect"
+  | "alarm"
+  | "webSocketMessage"
+  | "webSocketClose"
+  | "webSocketError";
+
+const reservedMethodNames = new Set<string>([
+  "constructor",
+  "dup",
+  "fetch",
+  "connect",
+  "alarm",
+  "webSocketMessage",
+  "webSocketClose",
+  "webSocketError",
+]);
+
+type WorkerBaseContext<ROut> = ExecutionContext | WorkerContext | WorkerEnvironment | ROut;
+type WorkerFetchContext<ROut> =
+  | WorkerBaseContext<ROut>
+  | NativeRequest
+  | HttpServerRequest.HttpServerRequest
+  | Scope.Scope;
+type WorkerRpcContext<ROut> = WorkerBaseContext<ROut> | Scope.Scope;
+
+type RuntimeContext<ROut> = WorkerBaseContext<ROut>;
+
+const RunSymbol = Symbol.for("effect-cf/Worker/run");
+
+export type WorkerHandler<ROut, A = unknown> = Effect.Effect<A, unknown, WorkerFetchContext<ROut>>;
+
+export type WorkerRpcHandler<ROut, A = unknown> = Effect.Effect<A, unknown, WorkerRpcContext<ROut>>;
+
+export type WorkerRpc<ROut> = Record<string, (...args: Array<any>) => WorkerRpcHandler<ROut>>;
+
+export type WorkerRpcShape<Rpc extends WorkerRpc<ROut>, ROut> = {
+  readonly [Key in keyof Rpc]: Rpc[Key] extends (
+    ...args: infer Args
+  ) => Effect.Effect<infer A, unknown, WorkerRpcContext<ROut>>
+    ? (...args: Args) => Promise<A>
+    : never;
+};
+
+export type RpcHandlers<ROut, Api> = {
+  readonly [Key in keyof Api as Key extends keyof CloudflareWorkerEntrypoint
+    ? never
+    : Key extends string
+      ? Key extends ReservedMethodName
+        ? never
+        : [Api[Key]] extends [never]
+          ? never
+          : Api[Key] extends (...args: Array<any>) => Promise<unknown>
+            ? Key
+            : never
+      : never]: Api[Key] extends (...args: infer Args) => Promise<infer A>
+    ? (...args: Args) => WorkerRpcHandler<ROut, A>
+    : never;
+};
+
+export interface WorkerOptions<ROut, Rpc extends WorkerRpc<ROut>> {
+  readonly fetch?: Effect.Effect<Response, unknown, WorkerFetchContext<ROut>>;
+  readonly rpc?: Rpc;
+}
+
+export type WorkerClass<Rpc extends WorkerRpc<ROut>, ROut> = new (
+  ctx: globalThis.ExecutionContext,
+  env: WorkerEnv,
+) => CloudflareWorkerEntrypoint<WorkerEnv> & {
+  fetch(request: Request): Promise<Response>;
+} & WorkerRpcShape<Rpc, ROut>;
+
+export const make = <ROut, LayerError, const Rpc extends WorkerRpc<ROut> = Record<never, never>>(
+  layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>,
+  options: WorkerOptions<ROut, Rpc>,
+): WorkerClass<Rpc, ROut> => {
+  class EffectWorker extends CloudflareWorkerEntrypoint<WorkerEnv> {
+    readonly runtime: ManagedRuntime.ManagedRuntime<RuntimeContext<ROut>, LayerError>;
+
+    constructor(ctx: globalThis.ExecutionContext, env: WorkerEnv) {
+      super(ctx, env);
+
+      let runWaitUntilEffect: RunWaitUntilEffect = () =>
+        Promise.resolve(Exit.die(new Error("WorkerContext runtime is not initialized")));
+
+      const services = Layer.mergeAll(
+        Layer.succeed(ExecutionContext, ctx),
+        Layer.succeed(
+          WorkerContext,
+          fromExecutionContext(ctx, (effect) => runWaitUntilEffect(effect)),
+        ),
+        Layer.succeed(WorkerEnvironment, env),
+      );
+
+      const runtimeLayer = Entrypoint.provideEntrypointServices(layer, services);
+
+      this.runtime = ManagedRuntime.make(runtimeLayer);
+      runWaitUntilEffect = <A, E>(effect: Effect.Effect<A, E, never>) =>
+        this.runtime.runPromiseExit(effect as Effect.Effect<A, E, RuntimeContext<ROut>>);
+    }
+
+    [RunSymbol]<A, E>(effect: Effect.Effect<A, E, RuntimeContext<ROut> | Scope.Scope>): Promise<A> {
+      return this.runtime.runPromise(Effect.scoped(effect));
+    }
+
+    fetch(request: Request): Promise<Response> {
+      const fetchHandler = options.fetch;
+
+      if (fetchHandler === undefined) {
+        return Promise.resolve(new Response("Not Found", { status: 404 }));
+      }
+
+      return this[RunSymbol](
+        fetchHandler.pipe(
+          Effect.provideService(NativeRequest, request),
+          Effect.provideService(
+            HttpServerRequest.HttpServerRequest,
+            HttpServerRequest.fromWeb(request),
+          ),
+        ),
+      );
+    }
+  }
+
+  Entrypoint.defineEntrypointRpcMethods<EffectWorker>(
+    "Worker",
+    EffectWorker.prototype,
+    options.rpc,
+    reservedMethodNames,
+    (self, effect) => self[RunSymbol](effect),
+  );
+
+  return Entrypoint.assumeEntrypointClass<WorkerClass<Rpc, ROut>>(EffectWorker);
+};
+
+export const Tag = WorkerDefinition.Tag;
+
+export const method = WorkerDefinition.method;
+
+export const implement = WorkerDefinition.implement;
+
+export type Definition<
+  Id extends string = string,
+  Methods extends RpcDefinition.Methods = RpcDefinition.Methods,
+> = WorkerDefinition.Definition<Id, Methods>;
+
+export namespace Definition {
+  export type Any = WorkerDefinition.Definition.Any;
+}
+
+export type ServerApi<Self extends WorkerDefinition.Definition.Any> =
+  WorkerDefinition.ServerApi<Self>;
+
+export type Api<Self extends WorkerDefinition.Definition.Any> = WorkerDefinition.Api<Self>;
+
+export type Handlers<
+  ROut,
+  Self extends WorkerDefinition.Definition.Any,
+> = WorkerDefinition.Handlers<ROut, Self>;
+
+export type Options<ROut, Self extends WorkerDefinition.Definition.Any> = WorkerDefinition.Options<
+  ROut,
+  Self
+>;
+
+export type HandlerEffect<
+  ROut,
+  Self extends WorkerDefinition.Definition.Any,
+  Key extends keyof Self["methods"],
+> = WorkerDefinition.HandlerEffect<ROut, Self, Key>;