effect-cf 0.52.0 → 0.54.0

package/src/DurableObjectRpcWebSocket.ts

@@ -5,9 +5,9 @@ import * as Option from "effect/Option";
 import * as Predicate from "effect/Predicate";
 import * as Queue from "effect/Queue";
 import * as Schema from "effect/Schema";
-import * as RpcMessage from "effect/unstable/rpc/RpcMessage";
-import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization";
-import * as RpcServer from "effect/unstable/rpc/RpcServer";
+import * as RpcMessage from "effect/rpc/RpcMessage";
+import * as RpcSerialization from "effect/rpc/RpcSerialization";
+import * as RpcServer from "effect/rpc/RpcServer";
 
 import { DurableObjectState } from "./DurableObjectState";
 import {

package/src/DurableObjectSqlite.ts

@@ -3,8 +3,8 @@ import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Scheduler from "effect/Scheduler";
-import * as Reactivity from "effect/unstable/reactivity/Reactivity";
-import { SqlClient } from "effect/unstable/sql";
+import * as Reactivity from "effect/reactivity/Reactivity";
+import { SqlClient } from "effect/sql";
 
 import { DurableObjectState } from "./DurableObjectState";
 

package/src/HyperdrivePg.ts

@@ -2,7 +2,7 @@ import { PgClient } from "@effect/sql-pg";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Redacted from "effect/Redacted";
-import type { SqlClient, SqlError } from "effect/unstable/sql";
+import type { SqlClient, SqlError } from "effect/sql";
 
 import type * as Binding from "./Binding";
 import type { WorkerEnvironment } from "./Environment";

package/src/Mcp.ts

@@ -21,9 +21,9 @@ import * as Schema from "effect/Schema";
 import * as Sink from "effect/Sink";
 import * as Stream from "effect/Stream";
 import type { JsonSchema } from "effect";
-import * as AiError from "effect/unstable/ai/AiError";
-import * as Tool from "effect/unstable/ai/Tool";
-import type { Toolkit } from "effect/unstable/ai";
+import * as AiError from "effect/ai/AiError";
+import * as Tool from "effect/ai/Tool";
+import type { Toolkit } from "effect/ai";
 
 import { NativeRequest } from "./Worker";
 import { runNativeCallback } from "./internal/NativeCallback";
@@ -424,7 +424,7 @@ const registerToolkitTool = <Tools extends Record<string, Tool.Any>>(
  *
  * ```ts
  * import { Effect, Layer, Option } from "effect"
- * import { HttpRouter } from "effect/unstable/http"
+ * import { HttpRouter } from "effect/http"
  * import { Worker } from "effect-cf"
  * import * as Mcp from "effect-cf/mcp"
  *

package/src/RateLimit.ts

@@ -0,0 +1,110 @@
+import * as Context from "effect/Context";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Predicate from "effect/Predicate";
+import type { Layer } from "effect";
+
+import * as Binding from "./Binding";
+import type { WorkerEnvironment } from "./Environment";
+
+export type { BindingNotFoundError, BindingValidationError } from "./Binding";
+
+const expectedRateLimit = "Rate Limiting binding with limit()";
+
+export type RateLimitBinding = globalThis.RateLimit;
+export type RateLimitOptions = globalThis.RateLimitOptions;
+export type RateLimitOutcome = globalThis.RateLimitOutcome;
+
+export class RateLimitOperationError extends Data.TaggedError("RateLimitOperationError")<{
+  readonly binding: string;
+  readonly operation: "limit";
+  readonly cause: unknown;
+}> {
+  override get message(): string {
+    return `Cloudflare rate limit binding "${this.binding}" operation "limit" failed`;
+  }
+}
+
+export interface RateLimitDefinition {
+  readonly binding: string;
+}
+
+export interface RateLimitClient {
+  /** Denial is a successful result with success: false. Calls are never retried. */
+  readonly limit: (
+    options: RateLimitOptions,
+  ) => Effect.Effect<RateLimitOutcome, RateLimitOperationError>;
+  readonly rawUnsafe: Effect.Effect<RateLimitBinding>;
+  readonly definition: RateLimitDefinition;
+}
+
+declare const RateLimitServiceTypeId: unique symbol;
+
+export interface RateLimitService<Id extends string> {
+  readonly [RateLimitServiceTypeId]: {
+    readonly id: Id;
+  };
+}
+
+export type LayerOptions = {
+  readonly binding: string;
+};
+
+export interface TagClass<Self, Id extends string> extends Context.ServiceClass<
+  Self,
+  Id,
+  RateLimitClient
+> {
+  readonly id: Id;
+  readonly layer: (
+    options: LayerOptions,
+  ) => Layer.Layer<
+    Self,
+    Binding.BindingNotFoundError | Binding.BindingValidationError,
+    WorkerEnvironment
+  >;
+}
+
+export const isRateLimit = <Candidate>(value: Candidate): value is Candidate & RateLimitBinding =>
+  Predicate.hasProperty(value, "limit") && Predicate.isFunction(value.limit);
+
+export const makeClient =
+  (definition: RateLimitDefinition) =>
+  (rateLimit: RateLimitBinding): RateLimitClient => ({
+    definition,
+    limit: (options) =>
+      Effect.tryPromise({
+        try: () => rateLimit.limit(options),
+        catch: (cause) =>
+          new RateLimitOperationError({
+            binding: definition.binding,
+            operation: "limit",
+            cause,
+          }),
+      }),
+    rawUnsafe: Effect.succeed(rateLimit),
+  });
+
+export const layer = <Self>(
+  tag: Context.Service<Self, RateLimitClient>,
+  definition: RateLimitDefinition,
+) =>
+  Binding.layer(tag, definition.binding, isRateLimit, makeClient(definition), {
+    expected: expectedRateLimit,
+  });
+
+export const make = <Id extends string>(id: Id) => Tag<RateLimitService<Id>>()<Id>(id);
+
+export const Tag =
+  <Self>() =>
+  <Id extends string>(id: Id) => {
+    const tag = Context.Service<Self, RateLimitClient>()(id);
+
+    const makeLayer = (definition: LayerOptions) => layer(tag, definition);
+
+    // SAFETY: these are exactly the members required by TagClass, attached to the matching service tag.
+    return Object.assign(tag, {
+      id,
+      layer: makeLayer,
+    }) as TagClass<Self, Id>;
+  };

package/src/RpcWebSocketClient.ts

@@ -1,11 +1,11 @@
 import type * as Context from "effect/Context";
 import * as Layer from "effect/Layer";
-import type * as Rpc from "effect/unstable/rpc/Rpc";
-import * as RpcClient from "effect/unstable/rpc/RpcClient";
-import type { RpcClientError } from "effect/unstable/rpc/RpcClientError";
-import type * as RpcGroup from "effect/unstable/rpc/RpcGroup";
-import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization";
-import * as Socket from "effect/unstable/socket/Socket";
+import type * as Rpc from "effect/rpc/Rpc";
+import * as RpcClient from "effect/rpc/RpcClient";
+import type { RpcClientError } from "effect/rpc/RpcClientError";
+import type * as RpcGroup from "effect/rpc/RpcGroup";
+import * as RpcSerialization from "effect/rpc/RpcSerialization";
+import * as Socket from "effect/socket/Socket";
 
 export interface LayerOptions {
   readonly socket?: Parameters<typeof Socket.layerWebSocket>[1];

package/src/Worker.ts

@@ -5,10 +5,10 @@ import * as Layer from "effect/Layer";
 import * as References from "effect/References";
 import * as Tracer from "effect/Tracer";
 import type { Cause, ManagedRuntime, Scope } from "effect";
-import * as HttpEffect from "effect/unstable/http/HttpEffect";
-import * as HttpMiddleware from "effect/unstable/http/HttpMiddleware";
-import * as HttpServerRequest from "effect/unstable/http/HttpServerRequest";
-import * as HttpServerResponse from "effect/unstable/http/HttpServerResponse";
+import * as HttpEffect from "effect/http/HttpEffect";
+import * as HttpMiddleware from "effect/http/HttpMiddleware";
+import * as HttpServerRequest from "effect/http/HttpServerRequest";
+import * as HttpServerResponse from "effect/http/HttpServerResponse";
 
 import { WorkerEnvironment, type WorkerEnv } from "./Environment";
 import { fromMessage, fromMessageBatch, type QueueHandler } from "./Queue";

package/src/index.ts

@@ -27,6 +27,7 @@ export * as Kv from "./Kv";
 export * as Queue from "./Queue";
 export * as QueueBinding from "./QueueBinding";
 export * as QueueDefinition from "./QueueDefinition";
+export * as RateLimit from "./RateLimit";
 export * as R2 from "./R2";
 export * as Rpc from "./Rpc";
 export * as RpcDefinition from "./RpcDefinition";

package/src/internal/Entrypoint.ts

@@ -44,12 +44,16 @@ const invokeEntrypointRpcMethod = <Self>(
   );
 };
 
-export const provideEntrypointServices = <ROut, LayerError, RIn>(
+export const provideEntrypointServices = <ROut, LayerError, RIn, ServicesError = never>(
   layer: Layer.Layer<ROut, LayerError, RIn>,
-  services: Layer.Layer<RIn, never, never>,
-): Layer.Layer<ROut | RIn, LayerError, never> =>
+  services: Layer.Layer<RIn, ServicesError, never>,
+): Layer.Layer<ROut | RIn, LayerError | ServicesError, never> =>
   // SAFETY: provideMerge supplies RIn while retaining it in the output context for entrypoint consumers.
-  layer.pipe(Layer.provideMerge(services)) as Layer.Layer<ROut | RIn, LayerError, never>;
+  layer.pipe(Layer.provideMerge(services)) as Layer.Layer<
+    ROut | RIn,
+    LayerError | ServicesError,
+    never
+  >;
 
 export const defineEntrypointRpcMethods = <Self, Prototype extends object = object>(
   target: string,

package/src/internal/Runtime.ts

@@ -56,11 +56,14 @@ const runPromise = <A, E, R, LayerError>(
  * layer so the resulting runtime satisfies both the user services and the
  * platform services.
  */
-export const makeEntrypointRuntime = <ROut, LayerError, Services>(
+export const makeEntrypointRuntime = <ROut, LayerError, Services, ServicesError = never>(
   layer: Layer.Layer<ROut, LayerError, Services | WorkerEnvironment>,
   env: WorkerEnv,
-  services: Layer.Layer<Services>,
-): ManagedRuntime.ManagedRuntime<ROut | Services | WorkerEnvironment, LayerError> => {
+  services: Layer.Layer<Services, ServicesError>,
+): ManagedRuntime.ManagedRuntime<
+  ROut | Services | WorkerEnvironment,
+  LayerError | ServicesError
+> => {
   const entrypointServices = Layer.mergeAll(
     services,
     ConfigProvider.layer(WorkerConfig.providerFromEnv(env)),
@@ -70,6 +73,10 @@ export const makeEntrypointRuntime = <ROut, LayerError, Services>(
   return ManagedRuntime.make(provideEntrypointServices(layer, entrypointServices));
 };
 
+/** Close event resources before an outer lifecycle (such as alarm reconciliation) completes. */
+export const scopeEvent = <A, E, R>(effect: Effect.Effect<A, E, R | Scope.Scope>) =>
+  Effect.scoped(RpcTargets.withScope(effect));
+
 export function runEventPromise<A, E, R, LayerError>(
   runtime: ManagedRuntime.ManagedRuntime<R, LayerError>,
   effect: Effect.Effect<A, E, NoInfer<R> | Scope.Scope>,
@@ -105,7 +112,7 @@ export function runEventPromise<A, E, R, REvent, EventLayerError, LayerError>(
   const [runtime, effect, eventLayer, parent, onFailure] = args;
 
   if (eventLayer === undefined) {
-    const event = Effect.scoped(RpcTargets.withScope(effect));
+    const event = scopeEvent(effect);
 
     return runPromise(
       runtime,
@@ -114,9 +121,7 @@ export function runEventPromise<A, E, R, REvent, EventLayerError, LayerError>(
     );
   }
 
-  const event = Effect.scoped(
-    RpcTargets.withScope(effect.pipe(Effect.provide(eventLayer, { local: true }))),
-  );
+  const event = scopeEvent(effect.pipe(Effect.provide(eventLayer, { local: true })));
 
   return runPromise(
     runtime,

package/src/internal/Telemetry.ts

@@ -1,6 +1,6 @@
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
-import { Flusher } from "effect/unstable/observability/OtlpExporter";
+import { Flusher } from "effect/observability/OtlpExporter";
 
 /** Maximum event lifetime spent on an internally scheduled telemetry flush. */
 const scheduledFlushTimeout = "2 seconds";