@effect/platform 0.36.0 → 0.37.1

package/src/WorkerError.ts

@@ -23,7 +23,7 @@ export type WorkerErrorTypeId = typeof WorkerErrorTypeId
 export interface WorkerError extends Data.Case {
   readonly [WorkerErrorTypeId]: WorkerErrorTypeId
   readonly _tag: "WorkerError"
-  readonly reason: "spawn" | "decode" | "send" | "unknown"
+  readonly reason: "spawn" | "decode" | "send" | "unknown" | "encode"
   readonly error: unknown
   readonly stack?: string
 }
@@ -33,7 +33,7 @@ export interface WorkerError extends Data.Case {
  * @category errors
  */
 export const WorkerError: (
-  reason: "spawn" | "decode" | "send" | "unknown",
+  reason: "spawn" | "decode" | "send" | "unknown" | "encode",
   error: unknown,
   stack?: string
 ) => WorkerError = internal.WorkerError

package/src/WorkerRunner.ts

@@ -70,9 +70,10 @@ export declare namespace Runner {
    * @since 1.0.0
    * @category models
    */
-  export interface Options<O> {
-    readonly encode?: (message: O) => unknown
-    readonly transfers?: (message: O) => ReadonlyArray<unknown>
+  export interface Options<E, O> {
+    readonly encodeOutput?: (message: O) => Effect.Effect<never, WorkerError, unknown>
+    readonly encodeError?: (message: E) => Effect.Effect<never, WorkerError, unknown>
+    readonly transfers?: (message: O | E) => ReadonlyArray<unknown>
   }
 }
 
@@ -82,7 +83,7 @@ export declare namespace Runner {
  */
 export const make: <I, R, E, O>(
   process: (request: I) => Stream.Stream<R, E, O> | Effect.Effect<R, E, O>,
-  options?: Runner.Options<O> | undefined
+  options?: Runner.Options<E, O> | undefined
 ) => Effect.Effect<Scope.Scope | R | PlatformRunner, WorkerError, never> = internal.make
 
 /**

package/src/internal/command.ts

@@ -4,7 +4,7 @@ import { dual } from "effect/Function"
 import * as HashMap from "effect/HashMap"
 import * as Option from "effect/Option"
 import { pipeArguments } from "effect/Pipeable"
-import type ReadonlyArray from "effect/ReadonlyArray"
+import type * as ReadonlyArray from "effect/ReadonlyArray"
 import type { Scope } from "effect/Scope"
 import * as Stream from "effect/Stream"
 import type * as Command from "../Command.js"

package/src/internal/http/router.ts

@@ -7,8 +7,7 @@ import * as Effectable from "effect/Effectable"
 import { dual } from "effect/Function"
 import * as Inspectable from "effect/Inspectable"
 import * as Option from "effect/Option"
-import type { HTTPMethod } from "find-my-way"
-import FindMyWay from "find-my-way"
+import * as FindMyWay from "find-my-way-ts"
 import type * as App from "../../Http/App.js"
 import type * as Method from "../../Http/Method.js"
 import type * as Router from "../../Http/Router.js"
@@ -95,17 +94,14 @@ class RouterImpl<R, E> extends Effectable.StructuralClass<
 const toHttpApp = <R, E>(
   self: Router.Router<R, E>
 ): App.Default<Router.Router.ExcludeProvided<R>, E | Error.RouteNotFound> => {
-  const router = FindMyWay()
+  const router = FindMyWay.make<Router.Route<R, E>>()
   const mounts = Chunk.toReadonlyArray(self.mounts)
   const mountsLen = mounts.length
   Chunk.forEach(self.routes, (route) => {
-    function fn() {
-      return route
-    }
     if (route.method === "*") {
-      router.all(route.path, fn)
+      router.all(route.path, route)
     } else {
-      router.on(route.method, route.path, fn)
+      router.on(route.method, route.path, route)
     }
   })
   return Effect.flatMap(
@@ -124,14 +120,14 @@ const toHttpApp = <R, E>(
         }
       }
 
-      let result = router.find(request.method as HTTPMethod, request.url)
-      if (result === null && request.method === "HEAD") {
+      let result = router.find(request.method, request.url)
+      if (result === undefined && request.method === "HEAD") {
         result = router.find("GET", request.url)
       }
-      if (result === null) {
+      if (result === undefined) {
         return Effect.fail(Error.RouteNotFound({ request }))
       }
-      const route = (result.handler as any)() as Router.Route<R, E>
+      const route = result.handler
       if (route.prefix._tag === "Some") {
         request = sliceRequestUrl(request, route.prefix.value)
       }
@@ -157,7 +153,7 @@ class RouteImpl<R, E> implements Router.Route<R, E> {
   readonly [RouteTypeId]: Router.RouteTypeId
   constructor(
     readonly method: Method.Method | "*",
-    readonly path: string,
+    readonly path: Router.PathInput,
     readonly handler: Router.Route.Handler<R, E>,
     readonly prefix = Option.none<string>()
   ) {
@@ -186,7 +182,7 @@ export const fromIterable = <R, E>(
 /** @internal */
 export const makeRoute = <R, E>(
   method: Method.Method,
-  path: string,
+  path: Router.PathInput,
   handler: Router.Route.Handler<R, E>,
   prefix: Option.Option<string> = Option.none()
 ): Router.Route<R, E> => new RouteImpl(method, path, handler, prefix)
@@ -197,12 +193,14 @@ export const concat = dual<
   <R, E, R1, E1>(self: Router.Router<R, E>, that: Router.Router<R1, E1>) => Router.Router<R | R1, E | E1>
 >(2, (self, that) => new RouterImpl(Chunk.appendAll(self.routes, that.routes) as any, self.mounts))
 
-const removeTrailingSlash = (path: string) => (path.endsWith("/") ? path.slice(0, -1) : path)
+const removeTrailingSlash = (
+  path: Router.PathInput
+): Router.PathInput => (path.endsWith("/") ? path.slice(0, -1) : path) as any
 
 /** @internal */
 export const prefixAll = dual<
-  (prefix: string) => <R, E>(self: Router.Router<R, E>) => Router.Router<R, E>,
-  <R, E>(self: Router.Router<R, E>, prefix: string) => Router.Router<R, E>
+  (prefix: Router.PathInput) => <R, E>(self: Router.Router<R, E>) => Router.Router<R, E>,
+  <R, E>(self: Router.Router<R, E>, prefix: Router.PathInput) => Router.Router<R, E>
 >(
   2,
   (self, prefix) => {
@@ -211,7 +209,7 @@ export const prefixAll = dual<
       Chunk.map(self.routes, (route) =>
         new RouteImpl(
           route.method,
-          route.path === "/" ? prefix : prefix + route.path,
+          route.path === "/" ? prefix : prefix + route.path as Router.PathInput,
           route.handler,
           Option.orElse(
             Option.map(route.prefix, (_) => prefix + _),
@@ -226,12 +224,12 @@ export const prefixAll = dual<
 /** @internal */
 export const mount = dual<
   <R1, E1>(
-    path: string,
+    path: `/${string}`,
     that: Router.Router<R1, E1>
   ) => <R, E>(self: Router.Router<R, E>) => Router.Router<R | R1, E | E1>,
   <R, E, R1, E1>(
     self: Router.Router<R, E>,
-    path: string,
+    path: `/${string}`,
     that: Router.Router<R1, E1>
   ) => Router.Router<R | R1, E | E1>
 >(
@@ -242,14 +240,14 @@ export const mount = dual<
 /** @internal */
 export const mountApp = dual<
   <R1, E1>(
-    path: string,
+    path: `/${string}`,
     that: App.Default<R1, E1>
   ) => <R, E>(
     self: Router.Router<R, E>
   ) => Router.Router<Router.Router.ExcludeProvided<R | R1>, E | E1>,
   <R, E, R1, E1>(
     self: Router.Router<R, E>,
-    path: string,
+    path: `/${string}`,
     that: App.Default<R1, E1>
   ) => Router.Router<Router.Router.ExcludeProvided<R | R1>, E | E1>
 >(
@@ -261,27 +259,27 @@ export const mountApp = dual<
 /** @internal */
 export const route = (method: Method.Method | "*"): {
   <R1, E1>(
-    path: string,
+    path: Router.PathInput,
     handler: Router.Route.Handler<R1, E1>
   ): <R, E>(
     self: Router.Router<R, E>
   ) => Router.Router<Router.Router.ExcludeProvided<R | R1>, E1 | E>
   <R, E, R1, E1>(
     self: Router.Router<R, E>,
-    path: string,
+    path: Router.PathInput,
     handler: Router.Route.Handler<R1, E1>
   ): Router.Router<Router.Router.ExcludeProvided<R | R1>, E1 | E>
 } =>
   dual<
     <R1, E1>(
-      path: string,
+      path: Router.PathInput,
       handler: Router.Route.Handler<R1, E1>
     ) => <R, E>(
       self: Router.Router<R, E>
     ) => Router.Router<Router.Router.ExcludeProvided<R | R1>, E | E1>,
     <R, E, R1, E1>(
       self: Router.Router<R, E>,
-      path: string,
+      path: Router.PathInput,
       handler: Router.Route.Handler<R1, E1>
     ) => Router.Router<Router.Router.ExcludeProvided<R | R1>, E | E1>
   >(3, (self, path, handler) =>

package/src/internal/worker.ts

@@ -16,7 +16,7 @@ import type * as Scope from "effect/Scope"
 import * as Stream from "effect/Stream"
 import * as Transferable from "../Transferable.js"
 import type * as Worker from "../Worker.js"
-import type { WorkerError } from "../WorkerError.js"
+import { WorkerError } from "../WorkerError.js"
 
 /** @internal */
 export const defaultQueue = <I>() =>
@@ -55,7 +55,14 @@ export const makeManager = Effect.gen(function*(_) {
   let idCounter = 0
   return WorkerManager.of({
     [WorkerManagerTypeId]: WorkerManagerTypeId,
-    spawn<I, E, O>({ encode, permits = 1, queue, spawn, transfers = (_) => [] }: Worker.Worker.Options<I>) {
+    spawn<I, E, O>({
+      encode,
+      initialMessage,
+      permits = 1,
+      queue,
+      spawn,
+      transfers = (_) => []
+    }: Worker.Worker.Options<I>) {
       return Effect.gen(function*(_) {
         const id = idCounter++
         let requestIdCounter = 0
@@ -194,13 +201,13 @@ export const makeManager = Effect.gen(function*(_) {
                 const result = requestMap.get(id)
                 if (!result) return Effect.unit
                 const transferables = transfers(request)
-                const payload = encode ? encode(request) : request
-                return Effect.zipRight(
-                  Effect.catchAllCause(
-                    backing.send([id, 0, payload], transferables),
-                    (cause) => Queue.offer(result[0], Exit.failCause(cause))
+                return pipe(
+                  Effect.flatMap(
+                    encode ? encode(request) : Effect.succeed(request),
+                    (payload) => backing.send([id, 0, payload], transferables)
                   ),
-                  Deferred.await(result[1])
+                  Effect.catchAllCause((cause) => Queue.offer(result[0], Exit.failCause(cause))),
+                  Effect.zipRight(Deferred.await(result[1]))
                 )
               }),
               Effect.ensuring(semaphore.release(1)),
@@ -222,6 +229,14 @@ export const makeManager = Effect.gen(function*(_) {
           never
         >
 
+        if (initialMessage) {
+          yield* _(
+            Effect.sync(initialMessage),
+            Effect.flatMap(executeEffect),
+            Effect.mapError((error) => WorkerError("spawn", error))
+          )
+        }
+
         return { id, join, execute, executeEffect }
       }).pipe(Effect.parallelFinalizers)
     }
@@ -303,6 +318,9 @@ export const makeSerialized = <
         ...options,
         transfers(message) {
           return Transferable.get(message)
+        },
+        encode(message) {
+          return Effect.mapError(Serializable.serialize(message), (error) => WorkerError("encode", error))
         }
       })
     )
@@ -310,8 +328,7 @@ export const makeSerialized = <
       const parseSuccess = Schema.decode(Serializable.successSchema(message as any))
       const parseFailure = Schema.decode(Serializable.failureSchema(message as any))
       return pipe(
-        Serializable.serialize(message),
-        Stream.flatMap((message) => backing.execute(message)),
+        backing.execute(message),
         Stream.catchAll((error) => Effect.flatMap(parseFailure(error), Effect.fail)),
         Stream.mapEffect(parseSuccess)
       )
@@ -319,14 +336,10 @@ export const makeSerialized = <
     const executeEffect = <Req extends I>(message: Req) => {
       const parseSuccess = Schema.decode(Serializable.successSchema(message as any))
       const parseFailure = Schema.decode(Serializable.failureSchema(message as any))
-      return pipe(
-        Serializable.serialize(message),
-        Effect.flatMap((message) => backing.executeEffect(message)),
-        Effect.matchEffect({
-          onFailure: (error) => Effect.flatMap(parseFailure(error), Effect.fail),
-          onSuccess: parseSuccess
-        })
-      )
+      return Effect.matchEffect(backing.executeEffect(message), {
+        onFailure: (error) => Effect.flatMap(parseFailure(error), Effect.fail),
+        onSuccess: parseSuccess
+      })
     }
     return identity<Worker.SerializedWorker<I>>({
       id: backing.id,

package/src/internal/workerRunner.ts

@@ -28,7 +28,7 @@ export const PlatformRunner = Context.Tag<WorkerRunner.PlatformRunner>(
 /** @internal */
 export const make = <I, R, E, O>(
   process: (request: I) => Stream.Stream<R, E, O> | Effect.Effect<R, E, O>,
-  options?: WorkerRunner.Runner.Options<O>
+  options?: WorkerRunner.Runner.Options<E, O>
 ) =>
   Effect.gen(function*(_) {
     const platform = yield* _(PlatformRunner)
@@ -51,27 +51,46 @@ export const make = <I, R, E, O>(
           Effect.matchCauseEffect(stream, {
             onFailure: (cause) =>
               Either.match(Cause.failureOrCause(cause), {
-                onLeft: (error) => backing.send([id, 2, error]),
+                onLeft: (error) => {
+                  const transfers = options?.transfers ? options.transfers(error) : undefined
+                  return pipe(
+                    options?.encodeError ? options.encodeError(error) : Effect.succeed(error),
+                    Effect.flatMap((payload) => backing.send([id, 2, payload as any], transfers)),
+                    Effect.catchAllCause((cause) => backing.send([id, 3, Cause.squash(cause)]))
+                  )
+                },
                 onRight: (cause) => backing.send([id, 3, Cause.squash(cause)])
               }),
             onSuccess: (data) => {
               const transfers = options?.transfers ? options.transfers(data) : undefined
-              const payload = options?.encode ? options.encode(data) : data
-              return backing.send([id, 1, payload], transfers)
+              return pipe(
+                options?.encodeOutput ? options.encodeOutput(data) : Effect.succeed(data),
+                Effect.flatMap((payload) => backing.send([id, 0, payload], transfers)),
+                Effect.catchAllCause((cause) => backing.send([id, 3, Cause.squash(cause)]))
+              )
             }
           }) :
           pipe(
             stream,
-            Stream.tap((item) => {
-              const transfers = options?.transfers ? options.transfers(item) : undefined
-              const payload = options?.encode ? options.encode(item) : item
-              return backing.send([id, 0, payload], transfers)
+            Stream.tap((data) => {
+              const transfers = options?.transfers ? options.transfers(data) : undefined
+              return Effect.flatMap(
+                options?.encodeOutput ? Effect.orDie(options.encodeOutput(data)) : Effect.succeed(data),
+                (payload) => backing.send([id, 0, payload], transfers)
+              )
             }),
             Stream.runDrain,
             Effect.matchCauseEffect({
               onFailure: (cause) =>
                 Either.match(Cause.failureOrCause(cause), {
-                  onLeft: (error) => backing.send([id, 2, error]),
+                  onLeft: (error) => {
+                    const transfers = options?.transfers ? options.transfers(error) : undefined
+                    return pipe(
+                      options?.encodeError ? options.encodeError(error) : Effect.succeed(error),
+                      Effect.flatMap((payload) => backing.send([id, 2, payload as any], transfers)),
+                      Effect.catchAllCause((cause) => backing.send([id, 3, Cause.squash(cause)]))
+                    )
+                  },
                   onRight: (cause) => backing.send([id, 3, Cause.squash(cause)])
                 }),
               onSuccess: () => backing.send([id, 1])