effect 4.0.0-beta.53 → 4.0.0-beta.55

package/src/unstable/socket/Socket.ts

@@ -50,6 +50,12 @@ export interface Socket {
       readonly onOpen?: Effect.Effect<void> | undefined
     }
   ) => Effect.Effect<void, SocketError | E, R>
+  readonly runString: <_, E = never, R = never>(
+    handler: (_: string) => Effect.Effect<_, E, R> | void,
+    options?: {
+      readonly onOpen?: Effect.Effect<void> | undefined
+    }
+  ) => Effect.Effect<void, SocketError | E, R>
   readonly runRaw: <_, E = never, R = never>(
     handler: (_: string | Uint8Array) => Effect.Effect<_, E, R> | void,
     options?: {
@@ -63,6 +69,61 @@ export interface Socket {
   >
 }
 
+/**
+ * @since 4.0.0
+ * @category Constructors
+ */
+export const make = (options: {
+  readonly runRaw: <_, E, R>(
+    handler: (_: string | Uint8Array) => Effect.Effect<_, E, R> | void,
+    options?: {
+      readonly onOpen?: Effect.Effect<void> | undefined
+    }
+  ) => Effect.Effect<void, SocketError | E, R>
+  readonly run?: <_, E, R>(
+    handler: (_: Uint8Array) => Effect.Effect<_, E, R> | void,
+    options?: {
+      readonly onOpen?: Effect.Effect<void> | undefined
+    }
+  ) => Effect.Effect<void, SocketError | E, R>
+  readonly runString?: <_, E, R>(
+    handler: (_: string) => Effect.Effect<_, E, R> | void,
+    options?: {
+      readonly onOpen?: Effect.Effect<void> | undefined
+    }
+  ) => Effect.Effect<void, SocketError | E, R>
+  readonly writer: Effect.Effect<
+    (chunk: Uint8Array | string | CloseEvent) => Effect.Effect<void, SocketError>,
+    never,
+    Scope.Scope
+  >
+}): Socket =>
+  Socket.of({
+    [TypeId]: TypeId,
+    runRaw: options.runRaw,
+    run: options.run ?? ((handler, opts) =>
+      options.runRaw((data) =>
+        typeof data === "string"
+          ? handler(encoder.encode(data))
+          : data instanceof Uint8Array
+          ? handler(data)
+          : handler(new Uint8Array(data)), opts)),
+    runString: options.runString ??
+      (options.run ?
+        (handler, opts) => options.run!((data) => handler(decoder.decode(data)), opts) :
+        (handler, opts) =>
+          options.runRaw((data) =>
+            typeof data === "string"
+              ? handler(data)
+              : data instanceof Uint8Array
+              ? handler(decoder.decode(data))
+              : handler(decoder.decode(new Uint8Array(data))), opts)),
+    writer: options.writer
+  })
+
+const encoder = new TextEncoder()
+const decoder = new TextDecoder()
+
 const CloseEventTypeId = "~effect/socket/Socket/CloseEvent"
 
 /**
@@ -563,17 +624,6 @@ export const fromWebSocket = <RO>(
         }))
       )
 
-    const encoder = new TextEncoder()
-    const run = <_, E, R>(handler: (_: Uint8Array) => Effect.Effect<_, E, R> | void, opts?: {
-      readonly onOpen?: Effect.Effect<void> | undefined
-    }) =>
-      runRaw((data) =>
-        typeof data === "string"
-          ? handler(encoder.encode(data))
-          : data instanceof Uint8Array
-          ? handler(data)
-          : handler(new Uint8Array(data)), opts)
-
     const write = (chunk: Uint8Array | string | CloseEvent) =>
       latch.whenOpen(Effect.sync(() => {
         const ws = currentWS!
@@ -585,9 +635,7 @@ export const fromWebSocket = <RO>(
       }))
     const writer = Effect.succeed(write)
 
-    return Effect.succeed(Socket.of({
-      [TypeId]: TypeId,
-      run,
+    return Effect.succeed(make({
       runRaw,
       writer
     }))
@@ -711,15 +759,6 @@ export const fromTransformStream = <R>(acquire: Effect.Effect<InputTransformStre
         }))
       )
 
-    const encoder = new TextEncoder()
-    const run = <_, E, R>(handler: (_: Uint8Array) => Effect.Effect<_, E, R> | void, opts?: {
-      readonly onOpen?: Effect.Effect<void> | undefined
-    }) =>
-      runRaw((data) =>
-        typeof data === "string"
-          ? handler(encoder.encode(data))
-          : handler(data), opts)
-
     const writers = new WeakMap<InputTransformStream, WritableStreamDefaultWriter<Uint8Array>>()
     const getWriter = (stream: InputTransformStream) => {
       let writer = writers.get(stream)
@@ -751,9 +790,7 @@ export const fromTransformStream = <R>(acquire: Effect.Effect<InputTransformStre
         })
     )
 
-    return Effect.succeed(Socket.of({
-      [TypeId]: TypeId,
-      run,
+    return Effect.succeed(make({
       runRaw,
       writer
     }))

package/src/unstable/workflow/DurableDeferred.ts

@@ -1,13 +1,15 @@
 /**
  * @since 4.0.0
  */
+import * as Arr from "../../Array.ts"
 import type { NonEmptyReadonlyArray } from "../../Array.ts"
 import type * as Brand from "../../Brand.ts"
-import type * as Cause from "../../Cause.ts"
+import * as Cause from "../../Cause.ts"
 import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import * as Encoding from "../../Encoding.ts"
 import * as Exit from "../../Exit.ts"
+import * as Filter from "../../Filter.ts"
 import { dual } from "../../Function.ts"
 import * as Option from "../../Option.ts"
 import * as Schema from "../../Schema.ts"
@@ -193,11 +195,24 @@ export const into: {
     Effect.contextWith(
       (context: Context.Context<WorkflowEngine | WorkflowInstance>) => {
         const engine = Context.get(context, EngineTag)
-        const instance = Context.get(context, InstanceTag)
+        const parentInstance = Context.get(context, InstanceTag)
+        const instance = { ...parentInstance }
         return Effect.onExit(
-          effect,
+          Effect.provideService(effect, InstanceTag, instance),
           Effect.fnUntraced(function*(exit) {
-            if (instance.suspended) return
+            if (Exit.isFailure(exit)) {
+              const [reasons, interrupts] = Arr.partition(
+                exit.cause.reasons,
+                Filter.fromPredicate(Cause.isInterruptReason)
+              )
+              const hasInterruptsOnly = interrupts.length === exit.cause.reasons.length
+              if (hasInterruptsOnly && instance.suspended) {
+                parentInstance.suspended = true
+                return
+              } else if (interrupts.length > 0) {
+                exit = Exit.failCause(Cause.fromReasons(reasons))
+              }
+            }
             yield* engine.deferredDone(self, {
               workflowName: instance.workflow.name,
               executionId: instance.executionId,
@@ -244,7 +259,10 @@ export const raceAll = <
     if (Option.isSome(exit)) {
       return yield* Effect.flatten(exit.value) as Effect.Effect<any, any, any>
     }
-    return yield* into(Effect.raceAll(options.effects), deferred)
+    return yield* into(
+      Effect.raceAll(options.effects),
+      deferred
+    )
   })
 }
 

package/src/unstable/workflow/Workflow.ts

@@ -1,12 +1,14 @@
 /**
  * @since 4.0.0
  */
+import * as Arr from "../../Array.ts"
 import * as Cause from "../../Cause.ts"
 import * as Context from "../../Context.ts"
 import * as Data from "../../Data.ts"
 import * as Effect from "../../Effect.ts"
 import * as Exit from "../../Exit.ts"
 import * as Fiber from "../../Fiber.ts"
+import * as Filter from "../../Filter.ts"
 import { constFalse, constTrue, dual, identity } from "../../Function.ts"
 import * as Layer from "../../Layer.ts"
 import * as Option from "../../Option.ts"
@@ -578,13 +580,20 @@ export const intoResult = <A, E, R>(
       Effect.scoped,
       Effect.matchCauseEffect({
         onSuccess: (value) => Effect.succeed(new Complete({ exit: Exit.succeed(value) })),
-        onFailure: (cause): Effect.Effect<Result<A, E>> =>
-          instance.suspended
+        onFailure: (cause): Effect.Effect<Result<A, E>> => {
+          const [reasons, interrupts] = Arr.partition(
+            cause.reasons,
+            Filter.fromPredicate(Cause.isInterruptReason)
+          )
+          const hasInterruptsOnly = interrupts.length === cause.reasons.length
+          const filtered = reasons.length === 0 ? cause : Cause.fromReasons(reasons)
+          return instance.suspended && hasInterruptsOnly
             ? Effect.succeed(new Suspended({ cause: instance.cause }))
-            : (!instance.interrupted && Cause.hasInterruptsOnly(cause)) ||
+            : (!instance.interrupted && hasInterruptsOnly) ||
                 (!captureDefects && Cause.hasDies(cause))
-            ? Effect.failCause(cause as Cause.Cause<never>)
-            : Effect.succeed(new Complete({ exit: Exit.failCause(cause) }))
+            ? Effect.failCause(filtered as Cause.Cause<never>)
+            : Effect.succeed(new Complete({ exit: Exit.failCause(filtered) }))
+        }
       }),
       (eff) =>
         Effect.onExitPrimitive(eff, (exit) => {
@@ -610,11 +619,6 @@ export const wrapActivityResult = <A, E, R>(
   Effect.contextWith((context: Context.Context<WorkflowInstance>) => {
     const instance = Context.get(context, InstanceTag)
     const state = instance.activityState
-    if (instance.suspended) {
-      return waitForZero(instance).pipe(
-        Effect.andThen(suspend(instance))
-      )
-    }
     if (state.count === 0) state.latch.closeUnsafe()
     state.count++
     return Effect.onExit(effect, (exit) => {