effect-cf 0.53.0 → 0.55.0

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/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,