effect-cf 0.20.1 → 0.23.0

package/src/DurableObject.ts

@@ -1,24 +1,12 @@
 import { DurableObject as CloudflareDurableObject } from "cloudflare:workers";
-import {
-  ConfigProvider,
-  Effect,
-  Layer,
-  ManagedRuntime,
-  type Context,
-  type Scope,
-  type Schema as S,
-} from "effect";
+import { Effect, Layer, type ManagedRuntime, type Scope } from "effect";
 
 import { NativeRequest } from "./Worker";
-import { WorkerConfig, WorkerEnvironment, type WorkerEnv } from "./Environment";
+import { WorkerEnvironment, type WorkerEnv } from "./Environment";
 import { DurableObjectState, fromDurableObjectState } from "./DurableObjectState";
 import { fromWebSocket, type DurableWebSocket } from "./DurableObjectWebSocket";
-import type * as Binding from "./Binding";
-import * as DurableObjectDefinition from "./DurableObjectDefinition";
-import type * as DurableObjectNamespace from "./DurableObjectNamespace";
-import type * as Rpc from "./Rpc";
-import * as CloudflareClock from "./internal/Clock";
 import * as Entrypoint from "./internal/Entrypoint";
+import * as Runtime from "./internal/Runtime";
 
 const reservedMethodNames = new Set<string>([
   "constructor",
@@ -168,17 +156,12 @@ export const make = <
     constructor(state: globalThis.DurableObjectState, env: WorkerEnv) {
       super(state, env);
 
-      const services = Layer.mergeAll(
-        CloudflareClock.layer,
-        ConfigProvider.layer(Effect.succeed(WorkerConfig.providerFromEnv(env))),
+      this.runtime = Runtime.makeEntrypointRuntime<ROut, LayerError, DurableObjectState>(
+        layer,
+        env,
         Layer.succeed(DurableObjectState, fromDurableObjectState(state)),
-        Layer.succeed(WorkerEnvironment, env),
       );
 
-      const runtimeLayer = Entrypoint.provideEntrypointServices(layer, services);
-
-      this.runtime = ManagedRuntime.make(runtimeLayer);
-
       const initialize = options.initialize;
 
       if (initialize !== undefined) {
@@ -190,15 +173,10 @@ export const make = <
       effect: Effect.Effect<A, E, HandlerContext<ROut | REvent>>,
       runOptions: RunOptions = {},
     ): Promise<A> {
-      const effectWithEventLayer =
-        runOptions.eventLayer === false || options.eventLayer === undefined
-          ? effect
-          : effect.pipe(Effect.provide(options.eventLayer, { local: true }));
-
-      return this.runtime.runPromise(
-        Effect.scoped(
-          effectWithEventLayer as Effect.Effect<A, E | EventLayerError, HandlerContext<ROut>>,
-        ),
+      return Runtime.runEventPromise(
+        this.runtime,
+        effect,
+        runOptions.eventLayer === false ? undefined : options.eventLayer,
       );
     }
 
@@ -273,135 +251,20 @@ export const make = <
   );
 };
 
-export type ServiceFreeSchema = S.Codec<any, any, never, never>;
-
-export interface Method<
-  Args extends ReadonlyArray<ServiceFreeSchema> = ReadonlyArray<ServiceFreeSchema>,
-  Success extends ServiceFreeSchema = ServiceFreeSchema,
-> {
-  readonly args: Args;
-  readonly success: Success;
-}
-
-export namespace Method {
-  export type Any = Method<ReadonlyArray<ServiceFreeSchema>, ServiceFreeSchema>;
-
-  type ArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema>> = Args extends readonly []
-    ? []
-    : Args extends readonly [
-          infer Head extends ServiceFreeSchema,
-          ...infer Tail extends ReadonlyArray<ServiceFreeSchema>,
-        ]
-      ? [S.Schema.Type<Head>, ...ArgsFromSchemas<Tail>]
-      : Array<S.Schema.Type<Args[number]>>;
-
-  export type Args<Self extends Any> = ArgsFromSchemas<Self["args"]>;
-
-  export type Success<Self extends Any> = S.Schema.Type<Self["success"]>;
-}
-
-export type Methods = Record<string, Method.Any>;
-
-export type ReservedMethodName = DurableObjectDefinition.ReservedMethodName;
-
-export type NoReservedMethods<MethodsShape extends Methods> =
-  Extract<keyof MethodsShape, ReservedMethodName> extends never ? MethodsShape : never;
-
-export interface Definition<Id extends string = string, MethodsShape extends Methods = Methods> {
-  readonly id: Id;
-  readonly methods: MethodsShape;
-}
-
-export namespace Definition {
-  export type Any = Definition<string, Methods>;
-}
-
-export type LayerOptions = DurableObjectDefinition.LayerOptions;
-
-export type ServerApi<Self extends Definition.Any> = {
-  readonly [Key in keyof Self["methods"]]: (
-    ...args: Method.Args<Self["methods"][Key]>
-  ) => Promise<Method.Success<Self["methods"][Key]>>;
-};
-
-export type Api<Self extends Definition.Any> = Rpc.Provider<ServerApi<Self>, ReservedMethodName>;
-
-export type Handlers<ROut, Self extends Definition.Any> = {
-  readonly [Key in keyof Self["methods"]]: (
-    ...args: Method.Args<Self["methods"][Key]>
-  ) => DurableObjectHandler<ROut, Method.Success<Self["methods"][Key]>>;
-};
-
-export interface Options<
-  ROut,
-  Self extends Definition.Any,
-  REvent = never,
-  EventLayerError = never,
-> extends Omit<
-  DurableObjectOptions<ROut, REvent, EventLayerError, Handlers<ROut | REvent, Self>>,
-  "rpc"
-> {
-  readonly rpc: Handlers<ROut | REvent, Self>;
-}
-
-export type TagClass<Self, Id extends string, MethodsShape extends Methods> = Context.ServiceClass<
-  Self,
-  Id,
-  DurableObjectNamespace.DurableObjectNamespaceEffectClient<
-    Api<Definition<Id, MethodsShape>>,
-    Definition<Id, MethodsShape>
-  >
-> &
-  DurableObjectNamespace.DurableObjectNamespaceStaticClient<
-    Self,
-    Api<Definition<Id, MethodsShape>>,
-    Definition<Id, MethodsShape>
-  > & {
-    readonly id: Id;
-    readonly methods: MethodsShape;
-    readonly make: <ROut, LayerError, REvent = never, EventLayerError = never>(
-      layer: Layer.Layer<ROut, LayerError, DurableObjectState | WorkerEnvironment>,
-      options: Options<ROut, Definition<Id, MethodsShape>, REvent, EventLayerError>,
-    ) => DurableObjectClass<Handlers<ROut | REvent, Definition<Id, MethodsShape>>, ROut | REvent>;
-    readonly layer: (
-      options: LayerOptions,
-    ) => Layer.Layer<
-      Self,
-      Binding.BindingNotFoundError | Binding.BindingValidationError,
-      WorkerEnvironment
-    >;
-  };
-
-export type TagFactory = <Self>() => <Id extends string, const MethodsShape extends Methods>(
-  id: Id,
-  methods: MethodsShape & NoReservedMethods<MethodsShape>,
-) => TagClass<Self, Id, MethodsShape>;
-
-export const Tag = DurableObjectDefinition.Tag as unknown as TagFactory;
-
-export const method = DurableObjectDefinition.method as {
-  <Success extends ServiceFreeSchema>(definition: {
-    readonly success: Success;
-  }): Method<readonly [], Success>;
-  <
-    const Args extends ReadonlyArray<ServiceFreeSchema>,
-    Success extends ServiceFreeSchema,
-  >(definition: {
-    readonly args: Args;
-    readonly success: Success;
-  }): Method<Args, Success>;
-};
-
-export const implement = DurableObjectDefinition.implement as unknown as <
-  ROut,
-  const Self extends Definition.Any,
->(
-  _definition: Self,
-  handlers: Handlers<ROut, Self>,
-) => Handlers<ROut, Self>;
-
-export type HandlerEffect<
-  ROut,
-  Self extends Definition.Any,
-  Key extends keyof Self["methods"],
-> = DurableObjectHandler<ROut, Method.Success<Self["methods"][Key]>>;
+export type {
+  Api,
+  Definition,
+  HandlerEffect,
+  Handlers,
+  LayerOptions,
+  Method,
+  Methods,
+  NoReservedMethods,
+  Options,
+  ReservedMethodName,
+  ServerApi,
+  ServiceFreeSchema,
+  TagClass,
+} from "./DurableObjectDefinition";
+
+export { implement, method, Tag } from "./DurableObjectDefinition";

package/src/DurableObjectAlarm.ts

@@ -2,6 +2,7 @@ import { Clock, Context, Data, DateTime, Duration, Effect, Exit, Layer, Schema a
 
 import { DurableObjectState } from "./DurableObjectState";
 import type { SqlStorageValue, StorageOperationError } from "./DurableObjectStorage";
+import * as ErrorMessage from "./internal/ErrorMessage";
 
 const INIT_TABLE_SQL = `
 CREATE TABLE IF NOT EXISTS effect_cf_scheduled_alarms (
@@ -46,26 +47,46 @@ interface NextAlarmRow extends Record<string, SqlStorageValue> {
 
 export class InvalidAlarmRefError extends Data.TaggedError("InvalidAlarmRefError")<{
   readonly cause: unknown;
-}> {}
+}> {
+  override get message(): string {
+    return `Invalid Durable Object alarm ref: ${ErrorMessage.causeMessage(this.cause)}`;
+  }
+}
 
 export class InvalidAlarmPayloadError extends Data.TaggedError("InvalidAlarmPayloadError")<{
   readonly cause: unknown;
-}> {}
+}> {
+  override get message(): string {
+    return `Invalid Durable Object alarm payload: ${ErrorMessage.causeMessage(this.cause)}`;
+  }
+}
 
 export class InvalidRepeatEveryError extends Data.TaggedError("InvalidRepeatEveryError")<{
   readonly cause: unknown;
-}> {}
+}> {
+  override get message(): string {
+    return `Invalid Durable Object alarm repeatEvery: ${ErrorMessage.causeMessage(this.cause)}`;
+  }
+}
 
 export class InvalidProcessDueAlarmsOptionsError extends Data.TaggedError(
   "InvalidProcessDueAlarmsOptionsError",
 )<{
   readonly cause: unknown;
-}> {}
+}> {
+  override get message(): string {
+    return `Invalid processDueAlarms options: ${ErrorMessage.causeMessage(this.cause)}`;
+  }
+}
 
 export class StoredAlarmDecodeError extends Data.TaggedError("StoredAlarmDecodeError")<{
   readonly cause: unknown;
   readonly storageId: string;
-}> {}
+}> {
+  override get message(): string {
+    return `Failed to decode stored alarm "${this.storageId}": ${ErrorMessage.causeMessage(this.cause)}`;
+  }
+}
 
 export type DurableObjectAlarmError =
   | InvalidAlarmPayloadError
@@ -355,7 +376,7 @@ const toRepeatEveryMillis = (input: Duration.Input | undefined) => {
 
   return Effect.try({
     try: () => {
-      const millis = Duration.toMillis(Duration.fromInputUnsafe(input));
+      const millis = Duration.toMillis(input);
 
       if (!Number.isFinite(millis) || millis <= 0) {
         throw new Error("Alarm repeatEvery must be a positive finite duration");
@@ -382,7 +403,7 @@ const toAlarmDue = (row: AlarmRow) =>
       _tag: "AlarmDue",
       id: row.alarm_id,
       payload: yield* decodeStoredPayload(row),
-      scheduledAt: DateTime.toUtc(DateTime.makeUnsafe(row.run_at)),
+      scheduledAt: DateTime.makeUnsafe(row.run_at),
       tag: row.tag,
     });
   });
@@ -404,7 +425,7 @@ const getProcessLimit = (options: ProcessDueAlarmsOptions<unknown, unknown> | un
 const toFailureRescheduleMillis = (input: Duration.Input) =>
   Effect.try({
     try: () => {
-      const millis = Duration.toMillis(Duration.fromInputUnsafe(input));
+      const millis = Duration.toMillis(input);
 
       if (!Number.isFinite(millis) || millis <= 0) {
         throw new Error("Alarm failure rescheduleAfter must be a positive finite duration");
@@ -594,7 +615,7 @@ export const define = <const Definitions extends AlarmDefinitions>(definitions:
 export class DurableObjectAlarm extends Context.Service<DurableObjectAlarm, AlarmScheduler>()(
   "effect-cf/DurableObjectAlarm",
 ) {
-  static readonly layer = Layer.effect(
+  static readonly layer: Layer.Layer<DurableObjectAlarm, never, DurableObjectState> = Layer.effect(
     DurableObjectAlarm,
     Effect.gen(function* () {
       const state = yield* DurableObjectState;

package/src/DurableObjectDefinition.ts

@@ -38,15 +38,10 @@ export namespace Method {
       ? [S.Schema.Type<Head>, ...ArgsFromSchemas<Tail>]
       : Array<S.Schema.Type<Args[number]>>;
 
-  type EncodedArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema>> =
-    Args extends readonly []
-      ? []
-      : Args extends readonly [
-            infer Head extends ServiceFreeSchema,
-            ...infer Tail extends ReadonlyArray<ServiceFreeSchema>,
-          ]
-        ? [S.Codec.Encoded<Head>, ...EncodedArgsFromSchemas<Tail>]
-        : Array<S.Codec.Encoded<Args[number]>>;
+  /** Method schemas cross the wire through their canonical JSON codec. */
+  type EncodedArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema>> = {
+    [Index in keyof Args]: S.Json;
+  };
 
   export type Args<Self extends Any> = ArgsFromSchemas<Self["args"]>;
 
@@ -54,7 +49,7 @@ export namespace Method {
 
   export type Success<Self extends Any> = S.Schema.Type<Self["success"]>;
 
-  export type EncodedSuccess<Self extends Any> = S.Codec.Encoded<Self["success"]>;
+  export type EncodedSuccess<Self extends Any> = S.Json;
 }
 
 export type Methods = Record<string, Method.Any>;
@@ -144,7 +139,7 @@ export type LayerOptions = {
 
 export type TagClass<Self, Id extends string, MethodsShape extends Methods> = Context.ServiceClass<
   Self,
-  Id,
+  `effect-cf/DurableObject/${Id}`,
   DurableObjectNamespace.DurableObjectNamespaceEffectClient<
     Api<Definition<Id, MethodsShape>>,
     Definition<Id, MethodsShape>
@@ -241,23 +236,30 @@ export const Tag =
 
     type SelfDefinition = Definition<Id, MethodsShape>;
     type ClientApi = Api<SelfDefinition>;
+    const serviceKey: `effect-cf/DurableObject/${Id}` = `effect-cf/DurableObject/${id}`;
     const tag = Context.Service<
       Self,
       DurableObjectNamespace.DurableObjectNamespaceEffectClient<ClientApi, SelfDefinition>
-    >()(id);
+    >()(serviceKey);
 
     const bindingDefinition = (binding: LayerOptions) => ({
       ...binding,
       definition,
     });
 
-    const layer = (binding: LayerOptions) =>
+    const layer = (
+      binding: LayerOptions,
+    ): Layer.Layer<
+      Self,
+      Binding.BindingNotFoundError | Binding.BindingValidationError,
+      WorkerEnvironment
+    > =>
       DurableObjectNamespace.layer<Self, ClientApi, SelfDefinition>(
         tag,
         bindingDefinition(binding),
       );
 
-    const newUniqueId = Effect.fnUntraced(function* (
+    const newUniqueId = Effect.fn("DurableObject.newUniqueId")(function* (
       options?: globalThis.DurableObjectNamespaceNewUniqueIdOptions,
     ) {
       const namespace = yield* tag;
@@ -265,19 +267,19 @@ export const Tag =
       return yield* namespace.newUniqueId(options);
     });
 
-    const idFromName = Effect.fnUntraced(function* (name: string) {
+    const idFromName = Effect.fn("DurableObject.idFromName")(function* (name: string) {
       const namespace = yield* tag;
 
       return yield* namespace.idFromName(name);
     });
 
-    const idFromString = Effect.fnUntraced(function* (value: string) {
+    const idFromString = Effect.fn("DurableObject.idFromString")(function* (value: string) {
       const namespace = yield* tag;
 
       return yield* namespace.idFromString(value);
     });
 
-    const get = Effect.fnUntraced(function* (
+    const get = Effect.fn("DurableObject.get")(function* (
       objectId: globalThis.DurableObjectId,
       options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions,
     ) {
@@ -286,7 +288,7 @@ export const Tag =
       return yield* namespace.get(objectId, options);
     });
 
-    const getByName = Effect.fnUntraced(function* (
+    const getByName = Effect.fn("DurableObject.getByName")(function* (
       name: string,
       options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions,
     ) {
@@ -295,68 +297,70 @@ export const Tag =
       return yield* namespace.getByName(name, options);
     });
 
-    const jurisdiction = Effect.fnUntraced(function* (value: globalThis.DurableObjectJurisdiction) {
+    const jurisdiction = Effect.fn("DurableObject.jurisdiction")(function* (
+      value: globalThis.DurableObjectJurisdiction,
+    ) {
       const namespace = yield* tag;
 
       return yield* namespace.jurisdiction(value);
     });
 
-    const fetch = (
+    const fetch = Effect.fn("DurableObject.fetch")(function* (
       stub: DurableObjectNamespace.DurableObjectStubClient<ClientApi>,
       input: RequestInfo | URL,
       init?: RequestInit,
-    ) =>
-      Effect.gen(function* () {
-        const namespace = yield* tag;
+    ) {
+      const namespace = yield* tag;
 
-        return yield* namespace.fetch(stub, input, init);
-      });
+      return yield* namespace.fetch(stub, input, init);
+    });
 
-    const rpc = <Method extends keyof ClientApi>(
+    const rpc = Effect.fn("DurableObject.rpc")(function* <Method extends keyof ClientApi>(
       stub: DurableObjectNamespace.DurableObjectStubClient<ClientApi>,
       method: Method,
       ...args: ClientApi[Method] extends (...args: infer Args) => unknown ? Args : never
-    ) =>
-      Effect.gen(function* () {
-        const namespace = yield* tag;
+    ) {
+      const namespace = yield* tag;
 
-        return yield* (namespace.rpc as UnsafeInvoke<DurableObjectNamespace.DurableObjectRpcError>)(
-          stub,
-          method,
-          ...args,
-        );
-      });
+      return yield* (namespace.rpc as UnsafeInvoke<DurableObjectNamespace.DurableObjectRpcError>)(
+        stub,
+        method,
+        ...args,
+      );
+    });
 
-    const call = <Method extends keyof ClientApi>(
+    const call = Effect.fn("DurableObject.call")(function* <Method extends keyof ClientApi>(
       stub: DurableObjectNamespace.DurableObjectStubClient<ClientApi>,
       method: Method,
       ...args: ClientApi[Method] extends (...args: infer Args) => unknown ? Args : never
-    ) =>
-      Effect.gen(function* () {
-        const namespace = yield* tag;
+    ) {
+      const namespace = yield* tag;
 
-        return yield* (
-          namespace.call as UnsafeInvoke<DurableObjectNamespace.DurableObjectRpcError>
-        )(stub, method, ...args);
-      });
+      return yield* (namespace.call as UnsafeInvoke<DurableObjectNamespace.DurableObjectRpcError>)(
+        stub,
+        method,
+        ...args,
+      );
+    });
 
-    const scopedCall = <Method extends keyof ClientApi>(
+    const scopedCall = Effect.fn("DurableObject.scopedCall")(function* <
+      Method extends keyof ClientApi,
+    >(
       stub: DurableObjectNamespace.DurableObjectStubClient<ClientApi>,
       method: Method,
       ...args: ClientApi[Method] extends (...args: infer Args) => unknown ? Args : never
-    ) =>
-      Effect.gen(function* () {
-        const namespace = yield* tag;
+    ) {
+      const namespace = yield* tag;
 
-        return yield* (
-          namespace.scopedCall as UnsafeInvoke<DurableObjectNamespace.DurableObjectRpcError>
-        )(stub, method, ...args);
-      });
+      return yield* (
+        namespace.scopedCall as UnsafeInvoke<DurableObjectNamespace.DurableObjectRpcError>
+      )(stub, method, ...args);
+    });
 
-    const unsafeRaw = Effect.fnUntraced(function* () {
+    const rawUnsafe = Effect.fnUntraced(function* () {
       const namespace = yield* tag;
 
-      return yield* namespace.unsafeRaw;
+      return yield* namespace.rawUnsafe;
     });
 
     const directMethods = DurableObjectNamespace.makeDirectMethods<Self, ClientApi, SelfDefinition>(
@@ -384,7 +388,7 @@ export const Tag =
       rpc,
       call,
       scopedCall,
-      unsafeRaw,
+      rawUnsafe,
     }) as unknown as TagClass<Self, Id, MethodsShape>;
   };