effect-cf 0.6.0 → 0.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-cf",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Effect-native primitives for Cloudflare Workers and bindings.",
   "license": "MIT",
   "repository": {

package/src/Binding.ts

@@ -59,6 +59,21 @@ export interface BindingService<Self, Id extends string, Service> extends Contex
   >;
 }
 
+export const layer = <Self, Resource, Service = Resource>(
+  tag: Context.Service<Self, Service>,
+  binding: string,
+  isResource: (value: unknown) => value is Resource,
+  wrap?: (resource: Resource) => Service,
+): Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment> =>
+  Layer.effect(
+    tag,
+    Effect.gen(function* () {
+      const env = yield* WorkerEnvironment;
+      const resource = yield* getBinding(env, binding, isResource);
+      return wrap === undefined ? (resource as unknown as Service) : wrap(resource);
+    }),
+  );
+
 export const Service =
   <Self>() =>
   <Id extends string, Resource, Service = Resource>(
@@ -68,19 +83,11 @@ export const Service =
     wrap?: (resource: Resource) => Service,
   ): BindingService<Self, Id, Service> => {
     const tag = Context.Service<Self, Service>()(id);
-
-    const layer = Layer.effect(
-      tag,
-      Effect.gen(function* () {
-        const env = yield* WorkerEnvironment;
-        const resource = yield* getBinding(env, binding, isResource);
-        return wrap === undefined ? (resource as unknown as Service) : wrap(resource);
-      }),
-    );
+    const serviceLayer = layer(tag, binding, isResource, wrap);
 
     return Object.assign(tag, {
       [TypeId]: TypeId,
       binding,
-      layer,
+      layer: serviceLayer,
     }) as BindingService<Self, Id, Service>;
   };

package/src/DurableObject.ts

@@ -1,11 +1,15 @@
 import { DurableObject as CloudflareDurableObject } from "cloudflare:workers";
-import { Effect, Layer, ManagedRuntime, type Scope } from "effect";
+import { Effect, Layer, ManagedRuntime, type Context, type Scope } from "effect";
+import type { Schema as S } from "effect";
 
 import { NativeRequest } from "./Worker";
 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 Entrypoint from "./internal/Entrypoint";
 
 const reservedMethodNames = new Set<string>([
@@ -208,40 +212,130 @@ export const make = <
   return Entrypoint.assumeEntrypointClass<DurableObjectClass<Rpc, ROut>>(EffectDurableObject);
 };
 
-export const Tag = DurableObjectDefinition.Tag;
+export type ServiceFreeSchema = S.Codec<any, any, never, never>;
 
-export const method = DurableObjectDefinition.method;
+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 const implement = DurableObjectDefinition.implement;
+  export type Args<Self extends Any> = ArgsFromSchemas<Self["args"]>;
+
+  export type Success<Self extends Any> = S.Schema.Type<Self["success"]>;
+}
 
-export type Definition<
-  Id extends string = string,
-  Methods extends DurableObjectDefinition.Definition.Any["methods"] =
-    DurableObjectDefinition.Definition.Any["methods"],
-> = DurableObjectDefinition.Definition<Id, Methods>;
+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 = DurableObjectDefinition.Definition.Any;
+  export type Any = Definition<string, Methods>;
 }
 
-export type ServerApi<Self extends DurableObjectDefinition.Definition.Any> =
-  DurableObjectDefinition.ServerApi<Self>;
+export type LayerOptions = DurableObjectDefinition.LayerOptions;
 
-export type Api<Self extends DurableObjectDefinition.Definition.Any> =
-  DurableObjectDefinition.Api<Self>;
+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 Handlers<
-  ROut,
-  Self extends DurableObjectDefinition.Definition.Any,
-> = DurableObjectDefinition.Handlers<ROut, Self>;
+export type Api<Self extends Definition.Any> = Rpc.Provider<ServerApi<Self>, ReservedMethodName>;
 
-export type Options<
+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> extends Omit<
+  DurableObjectOptions<ROut, Handlers<ROut, Self>>,
+  "rpc"
+> {
+  readonly rpc: Handlers<ROut, 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>(
+      layer: Layer.Layer<ROut, LayerError, DurableObjectState | WorkerEnvironment>,
+      options: Options<ROut, Definition<Id, MethodsShape>>,
+    ) => DurableObjectClass<Handlers<ROut, Definition<Id, MethodsShape>>, ROut>;
+    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,
-  Self extends DurableObjectDefinition.Definition.Any,
-> = DurableObjectDefinition.Options<ROut, Self>;
+  const Self extends Definition.Any,
+>(
+  _definition: Self,
+  handlers: Handlers<ROut, Self>,
+) => Handlers<ROut, Self>;
 
 export type HandlerEffect<
   ROut,
-  Self extends DurableObjectDefinition.Definition.Any,
+  Self extends Definition.Any,
   Key extends keyof Self["methods"],
-> = DurableObjectDefinition.HandlerEffect<ROut, Self, Key>;
+> = DurableObjectHandler<ROut, Method.Success<Self["methods"][Key]>>;

package/src/DurableObjectDefinition.ts

@@ -1,22 +1,68 @@
-import { Effect, type Layer } from "effect";
+import { Context, Effect, type Layer } from "effect";
+import type { Schema as S } from "effect";
 
+import * as Binding from "./Binding";
 import * as DurableObjectEntrypoint from "./DurableObject";
 import type { DurableObjectHandler } from "./DurableObject";
 import * as DurableObjectNamespace from "./DurableObjectNamespace";
 import type { DurableObjectState } from "./DurableObjectState";
+import type * as Rpc from "./Rpc";
 import * as RpcDefinition from "./RpcDefinition";
 import type { WorkerEnvironment } from "./Environment";
 
+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]>>;
+
+  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]>>;
+
+  export type Args<Self extends Any> = ArgsFromSchemas<Self["args"]>;
+
+  export type EncodedArgs<Self extends Any> = EncodedArgsFromSchemas<Self["args"]>;
+
+  export type Success<Self extends Any> = S.Schema.Type<Self["success"]>;
+
+  export type EncodedSuccess<Self extends Any> = S.Codec.Encoded<Self["success"]>;
+}
+
+export type Methods = Record<string, Method.Any>;
+
 /**
  * RPC contract for a Durable Object class.
  */
-export type Definition<
-  Id extends string = string,
-  Methods extends RpcDefinition.Methods = RpcDefinition.Methods,
-> = RpcDefinition.Definition<Id, Methods>;
+export interface Definition<Id extends string = string, MethodsShape extends Methods = Methods> {
+  readonly id: Id;
+  readonly methods: MethodsShape;
+}
 
 export namespace Definition {
-  export type Any = RpcDefinition.Definition.Any;
+  export type Any = Definition<string, Methods>;
 }
 
 export type ReservedMethodName =
@@ -27,6 +73,9 @@ export type ReservedMethodName =
   | "webSocketClose"
   | "webSocketError";
 
+export type NoReservedMethods<MethodsShape extends Methods> =
+  Extract<keyof MethodsShape, ReservedMethodName> extends never ? MethodsShape : never;
+
 const reservedMethodNames = new Set<string>([
   "constructor",
   "dup",
@@ -40,38 +89,27 @@ const reservedMethodNames = new Set<string>([
 /**
  * Promise-based client API derived from a Durable Object definition.
  */
-export type ServerApi<Self extends Definition.Any> = RpcDefinition.Definition.ServerApi<Self>;
-
-export type Api<Self extends Definition.Any> = RpcDefinition.Definition.Api<
-  Self,
-  ReservedMethodName
->;
+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]>>;
+};
 
-declare const NamespaceServiceTypeId: unique symbol;
-
-/**
- * Nominal service marker for a Durable Object namespace binding.
- */
-export interface NamespaceService<Id extends string, Self extends Definition.Any> {
-  readonly [NamespaceServiceTypeId]: {
-    readonly id: Id;
-    readonly definition: Self;
-  };
-}
+export type Api<Self extends Definition.Any> = Rpc.Provider<ServerApi<Self>, ReservedMethodName>;
 
 /**
  * Effect handlers for each RPC method in a Durable Object definition.
  */
 export type Handlers<ROut, Self extends Definition.Any> = {
   readonly [Key in keyof Self["methods"]]: (
-    ...args: RpcDefinition.Method.Args<Self["methods"][Key]>
-  ) => DurableObjectHandler<ROut, RpcDefinition.Method.Success<Self["methods"][Key]>>;
+    ...args: Method.Args<Self["methods"][Key]>
+  ) => DurableObjectHandler<ROut, Method.Success<Self["methods"][Key]>>;
 };
 
 type BoundaryHandlers<ROut, Self extends Definition.Any> = {
   readonly [Key in keyof Self["methods"]]: (
     ...args: Array<unknown>
-  ) => DurableObjectHandler<ROut, RpcDefinition.Method.EncodedSuccess<Self["methods"][Key]>>;
+  ) => DurableObjectHandler<ROut, Method.EncodedSuccess<Self["methods"][Key]>>;
 };
 
 /**
@@ -84,10 +122,56 @@ export interface Options<ROut, Self extends Definition.Any> extends Omit<
   readonly rpc: Handlers<ROut, Self>;
 }
 
+export type LayerOptions = {
+  readonly binding: string;
+};
+
+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>(
+      layer: Layer.Layer<ROut, LayerError, DurableObjectState | WorkerEnvironment>,
+      options: Options<ROut, Definition<Id, MethodsShape>>,
+    ) => DurableObjectEntrypoint.DurableObjectClass<
+      Handlers<ROut, Definition<Id, MethodsShape>>,
+      ROut
+    >;
+    readonly layer: (
+      options: LayerOptions,
+    ) => Layer.Layer<
+      Self,
+      Binding.BindingNotFoundError | Binding.BindingValidationError,
+      WorkerEnvironment
+    >;
+  };
+
 /**
  * Defines a single RPC method schema in a Durable Object definition.
  */
-export const method = RpcDefinition.method;
+export const method = RpcDefinition.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>;
+};
 
 /**
  * Creates a Durable Object RPC definition plus implementation/binding helpers.
@@ -102,9 +186,9 @@ export const method = RpcDefinition.method;
  * });
  * ```
  */
-const makeDefinition = <Id extends string, const MethodsShape extends RpcDefinition.Methods>(
+const makeDefinition = <Id extends string, const MethodsShape extends Methods>(
   id: Id,
-  methods: MethodsShape & RpcDefinition.NoReservedMethods<MethodsShape, ReservedMethodName>,
+  methods: MethodsShape & NoReservedMethods<MethodsShape>,
 ) => {
   type SelfDefinition = Definition<Id, MethodsShape>;
   RpcDefinition.assertNoReservedMethods("Durable Object", methods, reservedMethodNames);
@@ -119,58 +203,153 @@ const makeDefinition = <Id extends string, const MethodsShape extends RpcDefinit
         ...options,
         rpc: wrapHandlers(definition, options.rpc),
       }),
-    Namespace:
-      <Self>() =>
-      <BindingId extends string>(
-        bindingId: BindingId,
-        binding: Omit<
-          DurableObjectNamespace.DurableObjectNamespaceBindingDefinition<SelfDefinition>,
-          "definition"
-        >,
-      ) =>
-        DurableObjectNamespace.Service<Self, Api<SelfDefinition>>()<BindingId, SelfDefinition>(
-          bindingId,
-          {
-            ...binding,
-            definition,
-          },
-        ),
-    namespace: <BindingId extends string>(
-      bindingId: BindingId,
-      binding: Omit<
-        DurableObjectNamespace.DurableObjectNamespaceBindingDefinition<SelfDefinition>,
-        "definition"
-      >,
-    ) =>
-      DurableObjectNamespace.Service<
-        NamespaceService<BindingId, SelfDefinition>,
-        Api<SelfDefinition>
-      >()<BindingId, SelfDefinition>(bindingId, {
-        ...binding,
-        definition,
-      }),
   });
 };
 
-export const make = makeDefinition;
+export const make = <Id extends string, const MethodsShape extends Methods>(
+  id: Id,
+  methods: MethodsShape & NoReservedMethods<MethodsShape>,
+) =>
+  Tag<Definition<Id, MethodsShape>>()<Id, MethodsShape>(
+    id,
+    methods as MethodsShape & NoReservedMethods<MethodsShape>,
+  );
 
 export const Tag =
-  <_Self>() =>
-  <Id extends string, const MethodsShape extends RpcDefinition.Methods>(
+  <Self>() =>
+  <Id extends string, const MethodsShape extends Methods>(
     id: Id,
-    methods: MethodsShape & RpcDefinition.NoReservedMethods<MethodsShape, ReservedMethodName>,
+    methods: MethodsShape & NoReservedMethods<MethodsShape>,
   ) => {
     const definition = makeDefinition<Id, MethodsShape>(id, methods);
+    type SelfDefinition = Definition<Id, MethodsShape>;
+    type ClientApi = Api<SelfDefinition>;
+    const tag = Context.Service<
+      Self,
+      DurableObjectNamespace.DurableObjectNamespaceEffectClient<ClientApi, SelfDefinition>
+    >()(id);
+
+    const bindingDefinition = (binding: LayerOptions) => ({
+      ...binding,
+      definition,
+    });
+
+    const layer = (binding: LayerOptions) =>
+      DurableObjectNamespace.layer<Self, ClientApi, SelfDefinition>(
+        tag,
+        bindingDefinition(binding),
+      );
+
+    const newUniqueId = Effect.fnUntraced(function* (
+      options?: globalThis.DurableObjectNamespaceNewUniqueIdOptions,
+    ) {
+      const namespace = yield* tag;
+      return yield* namespace.newUniqueId(options);
+    });
+
+    const idFromName = Effect.fnUntraced(function* (name: string) {
+      const namespace = yield* tag;
+      return yield* namespace.idFromName(name);
+    });
+
+    const idFromString = Effect.fnUntraced(function* (value: string) {
+      const namespace = yield* tag;
+      return yield* namespace.idFromString(value);
+    });
+
+    const get = Effect.fnUntraced(function* (
+      objectId: globalThis.DurableObjectId,
+      options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions,
+    ) {
+      const namespace = yield* tag;
+      return yield* namespace.get(objectId, options);
+    });
+
+    const getByName = Effect.fnUntraced(function* (
+      name: string,
+      options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions,
+    ) {
+      const namespace = yield* tag;
+      return yield* namespace.getByName(name, options);
+    });
+
+    const jurisdiction = Effect.fnUntraced(function* (value: globalThis.DurableObjectJurisdiction) {
+      const namespace = yield* tag;
+      return yield* namespace.jurisdiction(value);
+    });
+
+    const fetch = (
+      stub: DurableObjectNamespace.DurableObjectStubClient<ClientApi>,
+      input: RequestInfo | URL,
+      init?: RequestInit,
+    ) =>
+      Effect.gen(function* () {
+        const namespace = yield* tag;
+        return yield* namespace.fetch(stub, input, init);
+      });
+
+    const rpc = <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;
+        return yield* namespace.rpc(stub, method as never, ...(args as never));
+      });
+
+    const call = <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;
+        return yield* namespace.call(stub, method as never, ...(args as never));
+      });
+
+    const scopedCall = <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;
+        return yield* namespace.scopedCall(stub, method as never, ...(args as never));
+      });
+
+    const unsafeRaw = Effect.fnUntraced(function* () {
+      const namespace = yield* tag;
+      return yield* namespace.unsafeRaw;
+    });
 
-    abstract class DurableObjectDefinitionClass {
-      static readonly id = definition.id;
-      static readonly methods = definition.methods;
-      static readonly make = definition.make;
-      static readonly Namespace = definition.Namespace;
-      static readonly namespace = definition.namespace;
-    }
+    const directMethods = DurableObjectNamespace.makeDirectMethods<Self, ClientApi, SelfDefinition>(
+      definition,
+      {
+        call: call as never,
+        fetch,
+        get,
+        getByName,
+      },
+    );
 
-    return DurableObjectDefinitionClass as (abstract new () => object) & typeof definition;
+    return Object.assign(tag, directMethods, {
+      id: definition.id,
+      methods: definition.methods,
+      make: definition.make,
+      layer,
+      newUniqueId,
+      idFromName,
+      idFromString,
+      get,
+      getByName,
+      jurisdiction,
+      fetch,
+      rpc,
+      call,
+      scopedCall,
+      unsafeRaw,
+    }) as unknown as TagClass<Self, Id, MethodsShape>;
   };
 
 export const DurableObject = Tag;
@@ -211,4 +390,4 @@ export type HandlerEffect<
   ROut,
   Self extends Definition.Any,
   Key extends keyof Self["methods"],
-> = DurableObjectHandler<ROut, RpcDefinition.Method.Success<Self["methods"][Key]>>;
+> = DurableObjectHandler<ROut, Method.Success<Self["methods"][Key]>>;