effect-cf 0.6.0 → 0.7.0

package/src/WorkflowBinding.ts

@@ -1,10 +1,8 @@
-import { Data, Effect, Option, Schema as S } from "effect";
+import { Context, Data, Effect, Option, Schema as S } from "effect";
 
 import * as Binding from "./Binding";
 import type * as RpcDefinition from "./RpcDefinition";
 
-const TypeId = "effect-cf/WorkflowBinding" as const;
-
 export type WorkflowInstanceCreateOptions<Payload> = Omit<
   globalThis.WorkflowInstanceCreateOptions<Payload>,
   "params"
@@ -66,20 +64,27 @@ export interface WorkflowBindingDefinition<
   readonly result: Result;
 }
 
-declare const WorkflowServiceTypeId: unique symbol;
-
-export interface WorkflowService<
-  Id extends string,
+export interface WorkflowBindingClient<
   Payload extends RpcDefinition.ServiceFreeSchema,
   Result extends RpcDefinition.ServiceFreeSchema,
 > {
-  readonly [WorkflowServiceTypeId]: {
-    readonly id: Id;
-    readonly payload: S.Schema.Type<Payload>;
-    readonly encodedPayload: S.Codec.Encoded<Payload>;
-    readonly result: S.Schema.Type<Result>;
-    readonly encodedResult: S.Codec.Encoded<Result>;
-  };
+  readonly create: (
+    payload: S.Schema.Type<Payload>,
+    options?: WorkflowInstanceCreateOptions<S.Codec.Encoded<Payload>>,
+  ) => Effect.Effect<
+    WorkflowInstance<S.Schema.Type<Result>>,
+    WorkflowOperationError | S.SchemaError
+  >;
+  readonly createBatch: (
+    batch: WorkflowInstanceCreateBatchOptions<S.Schema.Type<Payload>, S.Codec.Encoded<Payload>>,
+  ) => Effect.Effect<
+    ReadonlyArray<WorkflowInstance<S.Schema.Type<Result>>>,
+    WorkflowOperationError | S.SchemaError
+  >;
+  readonly get: (
+    instanceId: string,
+  ) => Effect.Effect<WorkflowInstance<S.Schema.Type<Result>>, WorkflowOperationError>;
+  readonly unsafeRaw: Effect.Effect<globalThis.Workflow<S.Codec.Encoded<Payload>>>;
 }
 
 export class WorkflowOperationError extends Data.TaggedError("WorkflowOperationError")<{
@@ -107,7 +112,7 @@ const tryWorkflowPromise = <A>(
     catch: (cause) => workflowError(binding, operation, cause),
   });
 
-const isWorkflow = <Payload>(value: unknown): value is globalThis.Workflow<Payload> => {
+export const isWorkflow = <Payload>(value: unknown): value is globalThis.Workflow<Payload> => {
   if (typeof value !== "object" || value === null) {
     return false;
   }
@@ -121,102 +126,83 @@ const isWorkflow = <Payload>(value: unknown): value is globalThis.Workflow<Paylo
   );
 };
 
-export const make = <
-  Id extends string,
+export const makeClient = <
   Payload extends RpcDefinition.ServiceFreeSchema,
   Result extends RpcDefinition.ServiceFreeSchema,
 >(
-  id: Id,
   definition: WorkflowBindingDefinition<Payload, Result>,
-) => Service<WorkflowService<Id, Payload, Result>>()<Id, Payload, Result>(id, definition);
-
-export const Service =
-  <Self>() =>
-  <
-    Id extends string,
-    Payload extends RpcDefinition.ServiceFreeSchema,
-    Result extends RpcDefinition.ServiceFreeSchema,
-  >(
-    id: Id,
-    definition: WorkflowBindingDefinition<Payload, Result>,
-  ) => {
-    type PayloadValue = S.Schema.Type<Payload>;
-    type EncodedPayload = S.Codec.Encoded<Payload>;
-    type ResultValue = S.Schema.Type<Result>;
-
-    const tag = Binding.Service<Self>()(
-      id,
-      definition.binding,
-      (value): value is globalThis.Workflow<EncodedPayload> => isWorkflow<EncodedPayload>(value),
-    );
-
-    const encodePayload = S.encodeEffect(definition.payload);
-    const decodeResult = S.decodeUnknownEffect(definition.result);
-
-    const wrapInstance = (raw: globalThis.WorkflowInstance): WorkflowInstance<ResultValue> => {
-      const operation = <A>(name: string, evaluate: () => Promise<A>) =>
-        tryWorkflowPromise(definition.binding, name, evaluate);
-
-      return {
-        raw,
-        id: raw.id,
-        pause: operation("pause", () => raw.pause()),
-        resume: operation("resume", () => raw.resume()),
-        terminate: operation("terminate", () => raw.terminate()),
-        restart: (options) =>
-          operation("restart", () =>
-            (raw as { restart(options?: WorkflowInstanceRestartOptions): Promise<void> }).restart(
-              options,
-            ),
+): ((
+  workflow: globalThis.Workflow<S.Codec.Encoded<Payload>>,
+) => WorkflowBindingClient<Payload, Result>) => {
+  type PayloadValue = S.Schema.Type<Payload>;
+  type EncodedPayload = S.Codec.Encoded<Payload>;
+  type ResultValue = S.Schema.Type<Result>;
+
+  const encodePayload = S.encodeEffect(definition.payload);
+  const decodeResult = S.decodeUnknownEffect(definition.result);
+
+  const wrapInstance = (raw: globalThis.WorkflowInstance): WorkflowInstance<ResultValue> => {
+    const operation = <A>(name: string, evaluate: () => Promise<A>) =>
+      tryWorkflowPromise(definition.binding, name, evaluate);
+
+    return {
+      raw,
+      id: raw.id,
+      pause: operation("pause", () => raw.pause()),
+      resume: operation("resume", () => raw.resume()),
+      terminate: operation("terminate", () => raw.terminate()),
+      restart: (options) =>
+        operation("restart", () =>
+          (raw as { restart(options?: WorkflowInstanceRestartOptions): Promise<void> }).restart(
+            options,
           ),
-        status: operation("status", () => raw.status()).pipe(
-          Effect.flatMap((status) =>
-            Effect.gen(function* () {
-              const output =
-                status.output === undefined
-                  ? Option.none<ResultValue>()
-                  : Option.some(
-                      yield* decodeResult(status.output).pipe(
-                        Effect.mapError(
-                          (cause) =>
-                            new WorkflowResultDecodeError({
-                              binding: definition.binding,
-                              instanceId: raw.id,
-                              cause,
-                            }),
-                        ),
+        ),
+      status: operation("status", () => raw.status()).pipe(
+        Effect.flatMap((status) =>
+          Effect.gen(function* () {
+            const output =
+              status.output === undefined
+                ? Option.none<ResultValue>()
+                : Option.some(
+                    yield* decodeResult(status.output).pipe(
+                      Effect.mapError(
+                        (cause) =>
+                          new WorkflowResultDecodeError({
+                            binding: definition.binding,
+                            instanceId: raw.id,
+                            cause,
+                          }),
                       ),
-                    );
-
-              return {
-                status: status.status,
-                output,
-                error: status.error === undefined ? Option.none() : Option.some(status.error),
-              };
-            }),
-          ),
+                    ),
+                  );
+
+            return {
+              status: status.status,
+              output,
+              error: status.error === undefined ? Option.none() : Option.some(status.error),
+            };
+          }),
         ),
-        sendEvent: (event) => operation("sendEvent", () => raw.sendEvent(event)),
-      };
+      ),
+      sendEvent: (event) => operation("sendEvent", () => raw.sendEvent(event)),
     };
+  };
 
-    const create = Effect.fnUntraced(function* (
+  return (workflow) => ({
+    create: Effect.fnUntraced(function* (
       payload: PayloadValue,
       options?: WorkflowInstanceCreateOptions<EncodedPayload>,
     ) {
-      const workflow = yield* tag;
       const encoded = yield* encodePayload(payload);
       const raw = yield* tryWorkflowPromise(definition.binding, "create", () =>
         workflow.create({ ...options, params: encoded }),
       );
 
       return wrapInstance(raw);
-    });
-
-    const createBatch = Effect.fnUntraced(function* (
+    }),
+    createBatch: Effect.fnUntraced(function* (
       batch: WorkflowInstanceCreateBatchOptions<PayloadValue, EncodedPayload>,
     ) {
-      const workflow = yield* tag;
       const encodedBatch: Array<globalThis.WorkflowInstanceCreateOptions<EncodedPayload>> = [];
 
       for (const item of batch) {
@@ -233,22 +219,27 @@ export const Service =
       );
 
       return rawInstances.map(wrapInstance);
-    });
-
-    const get = Effect.fnUntraced(function* (instanceId: string) {
-      const workflow = yield* tag;
-      const raw = yield* tryWorkflowPromise(definition.binding, "get", () =>
-        workflow.get(instanceId),
-      );
+    }),
+    get: (instanceId) =>
+      tryWorkflowPromise(definition.binding, "get", () => workflow.get(instanceId)).pipe(
+        Effect.map(wrapInstance),
+      ),
+    unsafeRaw: Effect.succeed(workflow),
+  });
+};
 
-      return wrapInstance(raw);
-    });
-
-    return Object.assign(tag, {
-      [TypeId]: TypeId,
-      binding: definition.binding,
-      create,
-      createBatch,
-      get,
-    });
-  };
+export const layer = <
+  Self,
+  Payload extends RpcDefinition.ServiceFreeSchema,
+  Result extends RpcDefinition.ServiceFreeSchema,
+>(
+  tag: Context.Service<Self, WorkflowBindingClient<Payload, Result>>,
+  definition: WorkflowBindingDefinition<Payload, Result>,
+) =>
+  Binding.layer(
+    tag,
+    definition.binding,
+    (value): value is globalThis.Workflow<S.Codec.Encoded<Payload>> =>
+      isWorkflow<S.Codec.Encoded<Payload>>(value),
+    makeClient(definition),
+  );

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;