effect-cf 0.6.0 → 0.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-cf",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "description": "Effect-native primitives for Cloudflare Workers and bindings.",
   "license": "MIT",
   "repository": {
@@ -21,6 +21,11 @@
       "import": "./dist/index.mjs",
       "default": "./dist/index.mjs"
     },
+    "./hyperdrive-pg": {
+      "types": "./dist/HyperdrivePg.d.mts",
+      "import": "./dist/HyperdrivePg.mjs",
+      "default": "./dist/HyperdrivePg.mjs"
+    },
     "./package.json": "./package.json"
   },
   "publishConfig": {
@@ -37,6 +42,7 @@
     "@cloudflare/vitest-pool-workers": "^0.15.0",
     "@cloudflare/workers-types": "^4.20260421.1",
     "@effect/sql-d1": "catalog:",
+    "@effect/sql-pg": "4.0.0-beta.65",
     "@effect/vitest": "catalog:",
     "effect": "catalog:",
     "typescript": "^6.0.2",
@@ -45,6 +51,12 @@
   },
   "peerDependencies": {
     "@effect/sql-d1": "^4.0.0-beta.65",
+    "@effect/sql-pg": "^4.0.0-beta.65",
     "effect": "^4.0.0-beta.65"
+  },
+  "peerDependenciesMeta": {
+    "@effect/sql-pg": {
+      "optional": true
+    }
   }
 }

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/D1.ts

@@ -1,17 +1,10 @@
 import { D1Client } from "@effect/sql-d1";
-import { Data, Effect, Layer } from "effect";
+import { 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`. */
@@ -44,29 +37,6 @@ const isD1Database = (value: unknown): value is D1Database => {
   );
 };
 
-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.
  */
@@ -76,9 +46,8 @@ export const make = <Id extends string>(id: Id, definition: D1Definition) =>
 /**
  * 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`.
+ * The returned service exposes the raw `D1Database` binding and `sqlLayer(...)`
+ * for providing `effect/unstable/sql` via `@effect/sql-d1`.
  *
  * @example
  * ```ts
@@ -102,34 +71,9 @@ export const Service =
         }),
       ).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/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]>>;