effect-cf 0.4.0 → 0.6.0

package/src/D1.ts

@@ -0,0 +1,135 @@
+import { D1Client } from "@effect/sql-d1";
+import { Data, Effect, Layer } from "effect";
+
+import * as Binding from "./Binding";
+
+const TypeId = "effect-cf/D1" as const;
+
+/** Error raised when a D1 operation fails. */
+export class D1OperationError extends Data.TaggedError("D1OperationError")<{
+  readonly binding: string;
+  readonly operation: string;
+  readonly cause: unknown;
+}> {}
+
+/** Typed D1 binding definition. */
+export interface D1Definition {
+  /** Binding name as configured in `wrangler.jsonc`. */
+  readonly binding: string;
+}
+
+/** Options forwarded to `@effect/sql-d1` when building a SQL client layer. */
+export type D1SqlLayerOptions = Omit<D1Client.D1ClientConfig, "db">;
+
+declare const D1ServiceTypeId: unique symbol;
+
+/** Nominal service marker for D1 services created with {@link make}. */
+export interface D1Service<Id extends string> {
+  readonly [D1ServiceTypeId]: {
+    readonly id: Id;
+  };
+}
+
+const isD1Database = (value: unknown): value is D1Database => {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+
+  const resource = value as Record<string, unknown>;
+
+  return (
+    typeof resource.prepare === "function" &&
+    typeof resource.batch === "function" &&
+    typeof resource.exec === "function"
+  );
+};
+
+const d1Error = (binding: string, operation: string, cause: unknown) =>
+  new D1OperationError({ binding, operation, cause });
+
+const tryD1Promise = <A>(
+  binding: string,
+  operation: string,
+  evaluate: () => Promise<A>,
+): Effect.Effect<A, D1OperationError> =>
+  Effect.tryPromise({
+    try: evaluate,
+    catch: (cause) => d1Error(binding, operation, cause),
+  });
+
+const tryD1Sync = <A>(
+  binding: string,
+  operation: string,
+  evaluate: () => A,
+): Effect.Effect<A, D1OperationError> =>
+  Effect.try({
+    try: evaluate,
+    catch: (cause) => d1Error(binding, operation, cause),
+  });
+
+/**
+ * Creates a typed D1 service tag plus Effect helpers.
+ */
+export const make = <Id extends string>(id: Id, definition: D1Definition) =>
+  Service<D1Service<Id>>()(id, definition);
+
+/**
+ * Builds a D1 service around a Cloudflare D1 database binding.
+ *
+ * The returned service exposes the raw `D1Database` binding, small native D1
+ * helpers, and `sqlLayer(...)` for providing `effect/unstable/sql` via
+ * `@effect/sql-d1`.
+ *
+ * @example
+ * ```ts
+ * class TodoDatabase extends D1.Service<TodoDatabase>()("TodoDatabase", {
+ *   binding: "TODO_DB",
+ * }) {}
+ *
+ * const SqlLive = TodoDatabase.sqlLayer();
+ * ```
+ */
+export const Service =
+  <Self>() =>
+  <Id extends string>(id: Id, definition: D1Definition) => {
+    const tag = Binding.Service<Self>()(id, definition.binding, isD1Database);
+
+    const sqlLayer = (options?: D1SqlLayerOptions) =>
+      Layer.unwrap(
+        Effect.gen(function* () {
+          const db = yield* tag;
+          return D1Client.layer({ ...options, db });
+        }),
+      ).pipe(Layer.provide(tag.layer));
+
+    const prepare = Effect.fnUntraced(function* (query: string) {
+      const db = yield* tag;
+      return yield* tryD1Sync(definition.binding, "prepare", () => db.prepare(query));
+    });
+
+    const batch = Effect.fnUntraced(function* <T = unknown>(
+      statements: ReadonlyArray<D1PreparedStatement>,
+    ) {
+      const db = yield* tag;
+      return yield* tryD1Promise(definition.binding, "batch", () => db.batch<T>([...statements]));
+    });
+
+    const exec = Effect.fnUntraced(function* (query: string) {
+      const db = yield* tag;
+      return yield* tryD1Promise(definition.binding, "exec", () => db.exec(query));
+    });
+
+    const unsafeRaw = Effect.fnUntraced(function* () {
+      return yield* tag;
+    });
+
+    return Object.assign(tag, {
+      [TypeId]: TypeId,
+      definition,
+      sqlLayer,
+      prepare,
+      batch,
+      exec,
+      unsafeRaw,
+    });
+  };

package/src/DurableObjectNamespace.ts

@@ -1,4 +1,4 @@
-import { Data, Effect } from "effect";
+import { Data, Effect, type Scope } from "effect";
 
 import * as Binding from "./Binding";
 import * as CloudflareRpc from "./Rpc";
@@ -110,21 +110,21 @@ type StubMethodSuccess<Api, Method extends keyof Api> = RpcInvocation.AsyncMetho
   Method
 >;
 
-type StubCall<Api extends object> = <Method extends StubMethodKey<Api>>(
+type StubCall<R, Api extends object> = <Method extends StubMethodKey<Api>>(
   stub: DurableObjectStubClient<Api>,
   method: Method,
   ...args: StubMethodArgs<Api, Method>
-) => Effect.Effect<StubMethodSuccess<Api, Method>, DurableObjectRpcError>;
+) => Effect.Effect<StubMethodSuccess<Api, Method>, DurableObjectRpcError, R>;
 
-type DurableObjectDirectClient<Self, Api extends object> = {
+type DurableObjectDirectClient<R, Api extends object> = {
   readonly fetch: (
     input: RequestInfo | URL,
     init?: RequestInit,
-  ) => Effect.Effect<globalThis.Response, DurableObjectFetchError, Self>;
+  ) => Effect.Effect<globalThis.Response, DurableObjectFetchError, R>;
 } & {
   readonly [Method in StubMethodKey<Api>]: (
     ...args: StubMethodArgs<Api, Method>
-  ) => Effect.Effect<StubMethodSuccess<Api, Method>, DurableObjectRpcError, Self>;
+  ) => Effect.Effect<StubMethodSuccess<Api, Method>, DurableObjectRpcError, R>;
 };
 
 type DefinitionNamespaceDirectMethods<
@@ -141,46 +141,89 @@ type DefinitionNamespaceDirectMethods<
 };
 
 type DefinitionDurableObjectDirectClient<
-  Self,
+  R,
   Definition extends DurableObjectDefinition.Definition.Any,
 > = {
   readonly fetch: (
     input: RequestInfo | URL,
     init?: RequestInit,
-  ) => Effect.Effect<globalThis.Response, DurableObjectFetchError, Self>;
+  ) => Effect.Effect<globalThis.Response, DurableObjectFetchError, R>;
 } & {
   readonly [Method in RpcDefinition.Definition.MethodNames<Definition>]: (
     ...args: RpcDefinition.Method.Args<Definition["methods"][Method]>
   ) => Effect.Effect<
     RpcDefinition.Method.Success<Definition["methods"][Method]>,
     DurableObjectRpcError,
-    Self
+    R
   >;
 };
 
 type DefinitionNamespaceDirectClientMethods<
-  Self,
+  R,
   Definition extends DurableObjectDefinition.Definition.Any,
 > = {
   readonly byName: (
     name: string,
     options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions,
-  ) => DefinitionDurableObjectDirectClient<Self, Definition>;
+  ) => DefinitionDurableObjectDirectClient<R, Definition>;
   readonly byId: (
     id: globalThis.DurableObjectId,
     options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions,
-  ) => DefinitionDurableObjectDirectClient<Self, Definition>;
+  ) => DefinitionDurableObjectDirectClient<R, Definition>;
 };
 
 type DirectMethods<
-  Self,
+  R,
   Api extends object,
   Definition,
 > = Definition extends DurableObjectDefinition.Definition.Any
   ? DefinitionNamespaceDirectMethods<Api, Definition> &
-      DefinitionNamespaceDirectClientMethods<Self, Definition>
+      DefinitionNamespaceDirectClientMethods<R, Definition>
   : {};
 
+export type DurableObjectNamespaceEffectClient<
+  Api extends object,
+  Definition extends DurableObjectDefinition.Definition.Any | undefined = undefined,
+> = DirectMethods<never, Api, Definition> & {
+  readonly newUniqueId: (
+    options?: globalThis.DurableObjectNamespaceNewUniqueIdOptions,
+  ) => Effect.Effect<globalThis.DurableObjectId>;
+  readonly idFromName: (name: string) => Effect.Effect<globalThis.DurableObjectId>;
+  readonly idFromString: (id: string) => Effect.Effect<globalThis.DurableObjectId>;
+  readonly get: (
+    id: globalThis.DurableObjectId,
+    options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions,
+  ) => Effect.Effect<DurableObjectStubClient<Api>>;
+  readonly getByName: (
+    name: string,
+    options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions,
+  ) => Effect.Effect<DurableObjectStubClient<Api>>;
+  readonly jurisdiction: (
+    jurisdiction: globalThis.DurableObjectJurisdiction,
+  ) => Effect.Effect<DurableObjectNamespaceClient<Api>>;
+  readonly fetch: (
+    stub: DurableObjectStubClient<Api>,
+    input: RequestInfo | URL,
+    init?: RequestInit,
+  ) => Effect.Effect<globalThis.Response, DurableObjectFetchError>;
+  readonly rpc: <Method extends StubMethodKey<Api>>(
+    stub: DurableObjectStubClient<Api>,
+    method: Method,
+    ...args: StubMethodArgs<Api, Method>
+  ) => Effect.Effect<StubMethodSuccess<Api, Method>, DurableObjectRpcError>;
+  readonly call: <Method extends StubMethodKey<Api>>(
+    stub: DurableObjectStubClient<Api>,
+    method: Method,
+    ...args: StubMethodArgs<Api, Method>
+  ) => Effect.Effect<StubMethodSuccess<Api, Method>, DurableObjectRpcError>;
+  readonly scopedCall: <Method extends StubMethodKey<Api>>(
+    stub: DurableObjectStubClient<Api>,
+    method: Method,
+    ...args: StubMethodArgs<Api, Method>
+  ) => Effect.Effect<Awaited<StubMethodSuccess<Api, Method>>, unknown, Scope.Scope>;
+  readonly unsafeRaw: Effect.Effect<DurableObjectNamespaceClient<Api>>;
+};
+
 /**
  * Creates a typed Effect service for a Durable Object namespace binding.
  *
@@ -230,25 +273,170 @@ export const Service =
       hasFunction(value, "newUniqueId") &&
       hasFunction(value, "jurisdiction");
 
-    const tag = Binding.Service<Self>()(id, definition.binding, (value): value is NamespaceClient =>
-      isDurableObjectNamespaceClient(value),
+    const makeClient = (
+      namespace: NamespaceClient,
+    ): DurableObjectNamespaceEffectClient<NamespaceApi, Definition> => {
+      const newUniqueId = (options?: globalThis.DurableObjectNamespaceNewUniqueIdOptions) =>
+        Effect.sync(() => namespace.newUniqueId(options));
+
+      const idFromName = (name: string) => Effect.sync(() => namespace.idFromName(name));
+
+      const idFromString = (id: string) => Effect.sync(() => namespace.idFromString(id));
+
+      const get = (
+        id: globalThis.DurableObjectId,
+        options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions,
+      ) => Effect.sync(() => namespace.get(id, options));
+
+      const getByName = (
+        name: string,
+        options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions,
+      ) => Effect.sync(() => namespace.getByName(name, options));
+
+      const jurisdiction = (value: globalThis.DurableObjectJurisdiction) =>
+        Effect.sync(() => namespace.jurisdiction(value));
+
+      const fetch = (stub: StubClient, input: RequestInfo | URL, init?: RequestInit) =>
+        Effect.tryPromise({
+          try: () => stub.fetch(input, init),
+          catch: (cause) => new DurableObjectFetchError({ binding: definition.binding, cause }),
+        });
+
+      const rpc = <Method extends StubMethodKey<NamespaceApi>>(
+        stub: StubClient,
+        method: Method,
+        ...args: StubMethodArgs<NamespaceApi, Method>
+      ) =>
+        Effect.gen(function* () {
+          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 DurableObjectRpcError({
+                        binding: definition.binding,
+                        method: methodName,
+                        cause,
+                      }),
+                  ),
+                );
+
+          return yield* RpcInvocation.invokeRpcMethod(
+            stub,
+            method,
+            encodedArgs as StubMethodArgs<NamespaceApi, Method>,
+            (cause) =>
+              new DurableObjectRpcError({
+                binding: definition.binding,
+                method: methodName,
+                cause,
+              }),
+          );
+        });
+
+      const call = <Method extends StubMethodKey<NamespaceApi>>(
+        stub: StubClient,
+        method: Method,
+        ...args: StubMethodArgs<NamespaceApi, Method>
+      ) =>
+        Effect.gen(function* () {
+          const methodName = String(method);
+          const value = yield* CloudflareRpc.resolve(yield* rpc(stub, method, ...args)).pipe(
+            Effect.mapError(
+              (cause) =>
+                new DurableObjectRpcError({
+                  binding: definition.binding,
+                  method: methodName,
+                  cause,
+                }),
+            ),
+          );
+
+          if (definition.definition === undefined) {
+            return value as StubMethodSuccess<NamespaceApi, Method>;
+          }
+
+          const decoded = yield* RpcDefinition.decodeSuccess(
+            definition.definition,
+            methodName as RpcDefinition.Definition.MethodNames<NonNullable<Definition>>,
+            value,
+          ).pipe(
+            Effect.mapError(
+              (cause) =>
+                new DurableObjectRpcError({
+                  binding: definition.binding,
+                  method: methodName,
+                  cause,
+                }),
+            ),
+          );
+
+          return decoded as StubMethodSuccess<NamespaceApi, Method>;
+        });
+
+      const scopedCall = <Method extends StubMethodKey<NamespaceApi>>(
+        stub: StubClient,
+        method: Method,
+        ...args: StubMethodArgs<NamespaceApi, Method>
+      ) =>
+        Effect.gen(function* () {
+          const result = yield* rpc(stub, method, ...args);
+          return yield* CloudflareRpc.scoped(result);
+        });
+
+      const directMethods = makeDirectMethods<never, NamespaceApi, Definition>(
+        definition.definition,
+        {
+          call,
+          fetch,
+          get,
+          getByName,
+        },
+      );
+
+      return Object.assign(directMethods, {
+        newUniqueId,
+        idFromName,
+        idFromString,
+        get,
+        getByName,
+        jurisdiction,
+        fetch,
+        rpc,
+        call,
+        scopedCall,
+        unsafeRaw: Effect.succeed(namespace),
+      }) as DurableObjectNamespaceEffectClient<NamespaceApi, Definition>;
+    };
+
+    const tag = Binding.Service<Self>()(
+      id,
+      definition.binding,
+      (value): value is NamespaceClient => isDurableObjectNamespaceClient(value),
+      makeClient,
     );
 
     const newUniqueId = Effect.fnUntraced(function* (
       options?: globalThis.DurableObjectNamespaceNewUniqueIdOptions,
     ) {
       const namespace = yield* tag;
-      return namespace.newUniqueId(options);
+      return yield* namespace.newUniqueId(options);
     });
 
     const idFromName = Effect.fnUntraced(function* (name: string) {
       const namespace = yield* tag;
-      return namespace.idFromName(name);
+      return yield* namespace.idFromName(name);
     });
 
     const idFromString = Effect.fnUntraced(function* (id: string) {
       const namespace = yield* tag;
-      return namespace.idFromString(id);
+      return yield* namespace.idFromString(id);
     });
 
     const get = Effect.fnUntraced(function* (
@@ -256,7 +444,7 @@ export const Service =
       options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions,
     ) {
       const namespace = yield* tag;
-      return namespace.get(id, options);
+      return yield* namespace.get(id, options);
     });
 
     const getByName = Effect.fnUntraced(function* (
@@ -264,12 +452,12 @@ export const Service =
       options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions,
     ) {
       const namespace = yield* tag;
-      return namespace.getByName(name, options);
+      return yield* namespace.getByName(name, options);
     });
 
     const jurisdiction = Effect.fnUntraced(function* (value: globalThis.DurableObjectJurisdiction) {
       const namespace = yield* tag;
-      return namespace.jurisdiction(value);
+      return yield* namespace.jurisdiction(value);
     });
 
     const fetch = (stub: StubClient, input: RequestInfo | URL, init?: RequestInit) =>
@@ -366,6 +554,11 @@ export const Service =
         return yield* CloudflareRpc.scoped(result);
       });
 
+    const unsafeRaw = Effect.fnUntraced(function* () {
+      const namespace = yield* tag;
+      return yield* namespace.unsafeRaw;
+    });
+
     const directMethods = makeDirectMethods<Self, NamespaceApi, Definition>(definition.definition, {
       call,
       fetch,
@@ -386,6 +579,7 @@ export const Service =
       rpc,
       call,
       scopedCall,
+      unsafeRaw,
     }) as typeof tag &
       DirectMethods<Self, NamespaceApi, Definition> & {
         readonly [TypeId]: typeof TypeId;
@@ -400,32 +594,33 @@ export const Service =
         readonly rpc: typeof rpc;
         readonly call: typeof call;
         readonly scopedCall: typeof scopedCall;
+        readonly unsafeRaw: typeof unsafeRaw;
       };
   };
 
 const makeDirectMethods = <
-  Self,
+  R,
   Api extends object,
   Definition extends DurableObjectDefinition.Definition.Any | undefined,
 >(
   rpcDefinition: Definition | undefined,
   helpers: {
-    readonly call: StubCall<Api>;
+    readonly call: StubCall<R, Api>;
     readonly fetch: (
       stub: DurableObjectStubClient<Api>,
       input: RequestInfo | URL,
       init?: RequestInit,
-    ) => Effect.Effect<globalThis.Response, DurableObjectFetchError>;
+    ) => Effect.Effect<globalThis.Response, DurableObjectFetchError, R>;
     readonly get: (
       id: globalThis.DurableObjectId,
       options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions,
-    ) => Effect.Effect<DurableObjectStubClient<Api>, never, Self>;
+    ) => Effect.Effect<DurableObjectStubClient<Api>, never, R>;
     readonly getByName: (
       name: string,
       options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions,
-    ) => Effect.Effect<DurableObjectStubClient<Api>, never, Self>;
+    ) => Effect.Effect<DurableObjectStubClient<Api>, never, R>;
   },
-): DirectMethods<Self, Api, Definition> => {
+): DirectMethods<R, Api, Definition> => {
   const methods = {} as Record<string, unknown>;
 
   if (rpcDefinition !== undefined) {
@@ -441,8 +636,8 @@ const makeDirectMethods = <
     }
 
     const makeClient = (
-      getStub: () => Effect.Effect<DurableObjectStubClient<Api>, never, Self>,
-    ): DurableObjectDirectClient<Self, Api> => {
+      getStub: () => Effect.Effect<DurableObjectStubClient<Api>, never, R>,
+    ): DurableObjectDirectClient<R, Api> => {
       const client = {
         fetch: (input: RequestInfo | URL, init?: RequestInit) =>
           Effect.gen(function* () {
@@ -465,7 +660,7 @@ const makeDirectMethods = <
           });
       }
 
-      return client as DurableObjectDirectClient<Self, Api>;
+      return client as DurableObjectDirectClient<R, Api>;
     };
 
     methods.byName = (
@@ -479,5 +674,5 @@ const makeDirectMethods = <
     ) => makeClient(() => helpers.get(id, options));
   }
 
-  return methods as DirectMethods<Self, Api, Definition>;
+  return methods as DirectMethods<R, Api, Definition>;
 };