effect-cf 0.6.0 → 0.8.0

package/src/WorkflowDefinition.ts

@@ -1,5 +1,6 @@
-import { Effect, Schema as S, type Layer } from "effect";
+import { Context, Effect, Schema as S, type Layer } from "effect";
 
+import * as Binding from "./Binding";
 import type { WorkerEnvironment } from "./Environment";
 import type { ExecutionContext, WorkerContext } from "./Worker";
 import type * as RpcDefinition from "./RpcDefinition";
@@ -24,15 +25,6 @@ export namespace Definition {
   >;
 }
 
-declare const BindingServiceTypeId: unique symbol;
-
-export interface BindingService<Id extends string, Self extends Definition.Any> {
-  readonly [BindingServiceTypeId]: {
-    readonly id: Id;
-    readonly definition: Self;
-  };
-}
-
 export type Handler<ROut, Self extends Definition.Any> = (
   payload: S.Schema.Type<Self["payload"]>,
 ) => Effect.Effect<
@@ -45,6 +37,62 @@ export interface Options<ROut, Self extends Definition.Any> {
   readonly run: Handler<ROut, Self>;
 }
 
+export type LayerOptions = {
+  readonly binding: string;
+};
+
+export interface TagClass<
+  Self,
+  Id extends string,
+  Payload extends RpcDefinition.ServiceFreeSchema,
+  Result extends RpcDefinition.ServiceFreeSchema,
+> extends Context.ServiceClass<Self, Id, WorkflowBinding.WorkflowBindingClient<Payload, Result>> {
+  readonly id: Id;
+  readonly payload: Payload;
+  readonly result: Result;
+  readonly make: <ROut, LayerError>(
+    layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>,
+    options: Options<ROut, Definition<Id, Payload, Result>>,
+  ) => WorkflowEntrypoint.WorkflowClass<S.Codec.Encoded<Payload>, S.Codec.Encoded<Result>, ROut>;
+  readonly layer: (
+    options: LayerOptions,
+  ) => Layer.Layer<
+    Self,
+    Binding.BindingNotFoundError | Binding.BindingValidationError,
+    WorkerEnvironment
+  >;
+  readonly create: (
+    payload: S.Schema.Type<Payload>,
+    options?: WorkflowBinding.WorkflowInstanceCreateOptions<S.Codec.Encoded<Payload>>,
+  ) => Effect.Effect<
+    WorkflowBinding.WorkflowInstance<S.Schema.Type<Result>>,
+    WorkflowBinding.WorkflowOperationError | S.SchemaError,
+    Self
+  >;
+  readonly createBatch: (
+    batch: WorkflowBinding.WorkflowInstanceCreateBatchOptions<
+      S.Schema.Type<Payload>,
+      S.Codec.Encoded<Payload>
+    >,
+  ) => Effect.Effect<
+    ReadonlyArray<WorkflowBinding.WorkflowInstance<S.Schema.Type<Result>>>,
+    WorkflowBinding.WorkflowOperationError | S.SchemaError,
+    Self
+  >;
+  readonly get: (
+    instanceId: string,
+  ) => Effect.Effect<
+    WorkflowBinding.WorkflowInstance<S.Schema.Type<Result>>,
+    WorkflowBinding.WorkflowOperationError,
+    Self
+  >;
+  readonly unsafeRaw: () => Effect.Effect<
+    globalThis.Workflow<S.Codec.Encoded<Payload>>,
+    never,
+    Self
+  >;
+}
+
 const makeDefinition = <
   Id extends string,
   Payload extends RpcDefinition.ServiceFreeSchema,
@@ -71,43 +119,23 @@ const makeDefinition = <
       WorkflowEntrypoint.make(layer, {
         run: wrapHandler(workflowDefinition, options.run),
       }),
-    Binding:
-      <Self>() =>
-      <BindingId extends string>(
-        bindingId: BindingId,
-        binding: Omit<
-          WorkflowBinding.WorkflowBindingDefinition<Payload, Result>,
-          "payload" | "result"
-        >,
-      ) =>
-        WorkflowBinding.Service<Self>()<BindingId, Payload, Result>(bindingId, {
-          ...binding,
-          payload: definition.payload,
-          result: definition.result,
-        }),
-    binding: <BindingId extends string>(
-      bindingId: BindingId,
-      binding: Omit<
-        WorkflowBinding.WorkflowBindingDefinition<Payload, Result>,
-        "payload" | "result"
-      >,
-    ) =>
-      WorkflowBinding.Service<BindingService<BindingId, SelfDefinition>>()<
-        BindingId,
-        Payload,
-        Result
-      >(bindingId, {
-        ...binding,
-        payload: definition.payload,
-        result: definition.result,
-      }),
   });
 };
 
-export const make = makeDefinition;
+export const make = <
+  Id extends string,
+  Payload extends RpcDefinition.ServiceFreeSchema,
+  Result extends RpcDefinition.ServiceFreeSchema,
+>(
+  id: Id,
+  definition: {
+    readonly payload: Payload;
+    readonly result: Result;
+  },
+) => Tag<Definition<Id, Payload, Result>>()(id, definition);
 
 export const Tag =
-  <_Self>() =>
+  <Self>() =>
   <
     Id extends string,
     Payload extends RpcDefinition.ServiceFreeSchema,
@@ -120,17 +148,54 @@ export const Tag =
     },
   ) => {
     const workflowDefinition = makeDefinition(id, definition);
+    const tag = Context.Service<Self, WorkflowBinding.WorkflowBindingClient<Payload, Result>>()(id);
 
-    abstract class WorkflowDefinitionClass {
-      static readonly id = workflowDefinition.id;
-      static readonly payload = workflowDefinition.payload;
-      static readonly result = workflowDefinition.result;
-      static readonly make = workflowDefinition.make;
-      static readonly Binding = workflowDefinition.Binding;
-      static readonly binding = workflowDefinition.binding;
-    }
+    const layer = (binding: LayerOptions) =>
+      WorkflowBinding.layer(tag, {
+        ...binding,
+        payload: definition.payload,
+        result: definition.result,
+      });
+
+    const create = Effect.fnUntraced(function* (
+      payload: S.Schema.Type<Payload>,
+      options?: WorkflowBinding.WorkflowInstanceCreateOptions<S.Codec.Encoded<Payload>>,
+    ) {
+      const workflow = yield* tag;
+      return yield* workflow.create(payload, options);
+    });
+
+    const createBatch = Effect.fnUntraced(function* (
+      batch: WorkflowBinding.WorkflowInstanceCreateBatchOptions<
+        S.Schema.Type<Payload>,
+        S.Codec.Encoded<Payload>
+      >,
+    ) {
+      const workflow = yield* tag;
+      return yield* workflow.createBatch(batch);
+    });
+
+    const get = Effect.fnUntraced(function* (instanceId: string) {
+      const workflow = yield* tag;
+      return yield* workflow.get(instanceId);
+    });
+
+    const unsafeRaw = Effect.fnUntraced(function* () {
+      const workflow = yield* tag;
+      return yield* workflow.unsafeRaw;
+    });
 
-    return WorkflowDefinitionClass as (abstract new () => object) & typeof workflowDefinition;
+    return Object.assign(tag, {
+      id: workflowDefinition.id,
+      payload: workflowDefinition.payload,
+      result: workflowDefinition.result,
+      make: workflowDefinition.make,
+      layer,
+      create,
+      createBatch,
+      get,
+      unsafeRaw,
+    }) as TagClass<Self, Id, Payload, Result>;
   };
 
 export const Workflow = Tag;

package/src/index.ts

@@ -8,10 +8,13 @@ export * as DurableObjectRpcWebSocket from "./DurableObjectRpcWebSocket";
 export * as DurableObjectState from "./DurableObjectState";
 export * as DurableObjectWebSocket from "./DurableObjectWebSocket";
 export * as DurableObjectStorage from "./DurableObjectStorage";
+export * as Hyperdrive from "./Hyperdrive";
+export * as Images from "./Images";
 export * as Kv from "./Kv";
 export * as Queue from "./Queue";
 export * as QueueBinding from "./QueueBinding";
 export * as QueueDefinition from "./QueueDefinition";
+export * as R2 from "./R2";
 export * as Rpc from "./Rpc";
 export * as RpcDefinition from "./RpcDefinition";
 export * as ServiceBinding from "./ServiceBinding";