@effect/platform 0.53.14 → 0.55.0

package/src/Http/ServerRequest.ts

@@ -133,7 +133,7 @@ export const upgradeChannel: <IE = never>() => Channel<
  * @since 1.0.0
  * @category schema
  */
-export const schemaCookies: <R, I extends Readonly<Record<string, string>>, A>(
+export const schemaCookies: <A, I extends Readonly<Record<string, string>>, R>(
   schema: Schema.Schema<A, I, R>,
   options?: ParseOptions | undefined
 ) => Effect.Effect<A, ParseResult.ParseError, ServerRequest | R> = internal.schemaCookies
@@ -142,7 +142,7 @@ export const schemaCookies: <R, I extends Readonly<Record<string, string>>, A>(
  * @since 1.0.0
  * @category schema
  */
-export const schemaHeaders: <R, I extends Readonly<Record<string, string>>, A>(
+export const schemaHeaders: <A, I extends Readonly<Record<string, string>>, R>(
   schema: Schema.Schema<A, I, R>,
   options?: ParseOptions | undefined
 ) => Effect.Effect<A, ParseResult.ParseError, ServerRequest | R> = internal.schemaHeaders
@@ -151,7 +151,7 @@ export const schemaHeaders: <R, I extends Readonly<Record<string, string>>, A>(
  * @since 1.0.0
  * @category schema
  */
-export const schemaSearchParams: <R, I extends Readonly<Record<string, string | Array<string> | undefined>>, A>(
+export const schemaSearchParams: <A, I extends Readonly<Record<string, string | Array<string> | undefined>>, R>(
   schema: Schema.Schema<A, I, R>,
   options?: ParseOptions | undefined
 ) => Effect.Effect<A, ParseResult.ParseError, ParsedSearchParams | R> = internal.schemaSearchParams
@@ -169,7 +169,7 @@ export const schemaBodyJson: <A, I, R>(
  * @since 1.0.0
  * @category schema
  */
-export const schemaBodyForm: <R, I extends Partial<Multipart.Persisted>, A>(
+export const schemaBodyForm: <A, I extends Partial<Multipart.Persisted>, R>(
   schema: Schema.Schema<A, I, R>,
   options?: ParseOptions | undefined
 ) => Effect.Effect<
@@ -182,7 +182,7 @@ export const schemaBodyForm: <R, I extends Partial<Multipart.Persisted>, A>(
  * @since 1.0.0
  * @category schema
  */
-export const schemaBodyUrlParams: <R, I extends Readonly<Record<string, string>>, A>(
+export const schemaBodyUrlParams: <A, I extends Readonly<Record<string, string>>, R>(
   schema: Schema.Schema<A, I, R>,
   options?: ParseOptions | undefined
 ) => Effect.Effect<A, ParseResult.ParseError | Error.RequestError, R | ServerRequest> = internal.schemaBodyUrlParams
@@ -191,7 +191,7 @@ export const schemaBodyUrlParams: <R, I extends Readonly<Record<string, string>>
  * @since 1.0.0
  * @category schema
  */
-export const schemaBodyMultipart: <R, I extends Partial<Multipart.Persisted>, A>(
+export const schemaBodyMultipart: <A, I extends Partial<Multipart.Persisted>, R>(
   schema: Schema.Schema<A, I, R>,
   options?: ParseOptions | undefined
 ) => Effect.Effect<

package/src/KeyValueStore.ts

@@ -76,7 +76,7 @@ export interface KeyValueStore {
   /**
    * Create a SchemaStore for the specified schema.
    */
-  readonly forSchema: <A, I, R>(schema: Schema.Schema<A, I, R>) => SchemaStore<R, A>
+  readonly forSchema: <A, I, R>(schema: Schema.Schema<A, I, R>) => SchemaStore<A, R>
 }
 
 /**
@@ -143,7 +143,7 @@ export type SchemaStoreTypeId = typeof SchemaStoreTypeId
  * @since 1.0.0
  * @category models
  */
-export interface SchemaStore<R, A> {
+export interface SchemaStore<A, R> {
   readonly [SchemaStoreTypeId]: SchemaStoreTypeId
   /**
    * Returns the value of the specified key if it exists.
@@ -202,6 +202,6 @@ export const layerSchema: <A, I, R>(
   schema: Schema.Schema<A, I, R>,
   tagIdentifier: string
 ) => {
-  readonly tag: Context.Tag<SchemaStore<R, A>, SchemaStore<R, A>>
-  readonly layer: Layer.Layer<SchemaStore<R, A>, never, KeyValueStore>
+  readonly tag: Context.Tag<SchemaStore<A, R>, SchemaStore<A, R>>
+  readonly layer: Layer.Layer<SchemaStore<A, R>, never, KeyValueStore>
 } = internal.layerSchema

package/src/Transferable.ts

@@ -82,11 +82,11 @@ export const schema: {
   <I>(
     f: (_: I) => Iterable<globalThis.Transferable>
   ): <A, R>(self: Schema.Schema<A, I, R>) => Schema.Schema<A, I, R>
-  <R, I, A>(
+  <A, I, R>(
     self: Schema.Schema<A, I, R>,
     f: (_: I) => Iterable<globalThis.Transferable>
   ): Schema.Schema<A, I, R>
-} = dual(2, <R, I, A>(
+} = dual(2, <A, I, R>(
   self: Schema.Schema<A, I, R>,
   f: (_: I) => Iterable<globalThis.Transferable>
 ) =>

package/src/Worker.ts

@@ -104,11 +104,11 @@ export declare namespace Worker {
    * @category models
    */
   export interface Options<I> {
-    readonly encode?: (message: I) => Effect.Effect<unknown, WorkerError>
-    readonly transfers?: (message: I) => ReadonlyArray<unknown>
-    readonly permits?: number
-    readonly queue?: WorkerQueue<I>
-    readonly initialMessage?: LazyArg<I>
+    readonly encode?: ((message: I) => Effect.Effect<unknown, WorkerError>) | undefined
+    readonly transfers?: ((message: I) => ReadonlyArray<unknown>) | undefined
+    readonly queue?: WorkerQueue<I> | undefined
+    readonly initialMessage?: LazyArg<I> | undefined
+    readonly permits?: number | undefined
   }
 
   /**
@@ -157,17 +157,10 @@ export declare namespace WorkerPool {
    * @since 1.0.0
    * @category models
    */
-  export type Options<I> =
-    & Worker.Options<I>
-    & ({
-      readonly onCreate?: (worker: Worker<I, unknown, unknown>) => Effect.Effect<void, WorkerError>
-      readonly size: number
-    } | {
-      readonly onCreate?: (worker: Worker<I, unknown, unknown>) => Effect.Effect<void, WorkerError>
-      readonly minSize: number
-      readonly maxSize: number
-      readonly timeToLive: Duration.DurationInput
-    })
+  export interface Options<I> extends Worker.Options<I> {
+    readonly onCreate?: (worker: Worker<I, unknown, unknown>) => Effect.Effect<void, WorkerError>
+    readonly size: number
+  }
 }
 
 /**
@@ -227,7 +220,7 @@ export const layerManager: Layer.Layer<WorkerManager, never, PlatformWorker> = i
  */
 export const makePool: <I, O, E>(
   options: WorkerPool.Options<I>
-) => Effect.Effect<WorkerPool<I, O, E>, never, WorkerManager | Spawner | Scope.Scope> = internal.makePool
+) => Effect.Effect<WorkerPool<I, O, E>, WorkerError, WorkerManager | Spawner | Scope.Scope> = internal.makePool
 
 /**
  * @since 1.0.0
@@ -236,7 +229,7 @@ export const makePool: <I, O, E>(
 export const makePoolLayer: <Tag, I, O, E>(
   tag: Context.Tag<Tag, WorkerPool<I, O, E>>,
   options: WorkerPool.Options<I>
-) => Layer.Layer<Tag, never, WorkerManager | Spawner> = internal.makePoolLayer
+) => Layer.Layer<Tag, WorkerError, WorkerManager | Spawner> = internal.makePoolLayer
 
 /**
  * @since 1.0.0
@@ -277,8 +270,8 @@ export declare namespace SerializedWorker {
    * @category models
    */
   export interface BaseOptions<I> {
-    readonly permits?: number
-    readonly queue?: WorkerQueue<I>
+    readonly permits?: number | undefined
+    readonly queue?: WorkerQueue<I> | undefined
   }
 }
 
@@ -341,7 +334,8 @@ export const makeSerialized: <I extends Schema.TaggedRequest.Any>(
  */
 export const makePoolSerialized: <I extends Schema.TaggedRequest.Any>(
   options: SerializedWorkerPool.Options<I>
-) => Effect.Effect<SerializedWorkerPool<I>, never, WorkerManager | Spawner | Scope.Scope> = internal.makePoolSerialized
+) => Effect.Effect<SerializedWorkerPool<I>, WorkerError, WorkerManager | Spawner | Scope.Scope> =
+  internal.makePoolSerialized
 
 /**
  * @since 1.0.0
@@ -350,7 +344,7 @@ export const makePoolSerialized: <I extends Schema.TaggedRequest.Any>(
 export const makePoolSerializedLayer: <Tag, I extends Schema.TaggedRequest.Any>(
   tag: Context.Tag<Tag, SerializedWorkerPool<I>>,
   options: SerializedWorkerPool.Options<I>
-) => Layer.Layer<Tag, never, WorkerManager | Spawner> = internal.makePoolSerializedLayer
+) => Layer.Layer<Tag, WorkerError, WorkerManager | Spawner> = internal.makePoolSerializedLayer
 
 /**
  * @since 1.0.0

package/src/WorkerError.ts

@@ -2,8 +2,7 @@
  * @since 1.0.0
  */
 import * as Schema from "@effect/schema/Schema"
-import * as Cause from "effect/Cause"
-import { identity } from "effect/Function"
+import type * as Cause from "effect/Cause"
 import * as Predicate from "effect/Predicate"
 import * as internal from "./internal/workerError.js"
 
@@ -25,27 +24,13 @@ export type WorkerErrorTypeId = typeof WorkerErrorTypeId
  */
 export const isWorkerError = (u: unknown): u is WorkerError => Predicate.hasProperty(u, WorkerErrorTypeId)
 
-const causeDefectPretty: Schema.Schema<unknown> = Schema.transform(
-  Schema.Unknown,
-  Schema.Unknown,
-  {
-    decode: identity,
-    encode: (defect) => {
-      if (Predicate.isObject(defect)) {
-        return Cause.pretty(Cause.die(defect))
-      }
-      return String(defect)
-    }
-  }
-)
-
 /**
  * @since 1.0.0
  * @category errors
  */
 export class WorkerError extends Schema.TaggedError<WorkerError>()("WorkerError", {
   reason: Schema.Literal("spawn", "decode", "send", "unknown", "encode"),
-  error: causeDefectPretty
+  error: Schema.CauseDefectUnknown
 }) {
   /**
    * @since 1.0.0
@@ -58,7 +43,7 @@ export class WorkerError extends Schema.TaggedError<WorkerError>()("WorkerError"
   static readonly Cause: Schema.Schema<
     Cause.Cause<WorkerError>,
     Schema.CauseEncoded<WorkerErrorFrom>
-  > = Schema.Cause({ defect: causeDefectPretty, error: this })
+  > = Schema.Cause({ error: this })
 
   /**
    * @since 1.0.0

package/src/internal/http/multipart.ts

@@ -118,7 +118,7 @@ export const SingleFileSchema: Schema.transform<
 })
 
 /** @internal */
-export const schemaPersisted = <R, I extends Partial<Multipart.Persisted>, A>(
+export const schemaPersisted = <A, I extends Partial<Multipart.Persisted>, R>(
   schema: Schema.Schema<A, I, R>,
   options?: ParseOptions | undefined
 ) => {

package/src/internal/http/router.ts

@@ -112,7 +112,7 @@ export const schemaNoBody = <
 }
 
 /** @internal */
-export const schemaParams = <R, I extends Readonly<Record<string, string | Array<string> | undefined>>, A>(
+export const schemaParams = <A, I extends Readonly<Record<string, string | Array<string> | undefined>>, R>(
   schema: Schema.Schema<A, I, R>,
   options?: ParseOptions | undefined
 ) => {
@@ -128,7 +128,7 @@ export const schemaParams = <R, I extends Readonly<Record<string, string | Array
 }
 
 /** @internal */
-export const schemaPathParams = <R, I extends Readonly<Record<string, string | undefined>>, A>(
+export const schemaPathParams = <A, I extends Readonly<Record<string, string | undefined>>, R>(
   schema: Schema.Schema<A, I, R>,
   options?: ParseOptions | undefined
 ) => {

package/src/internal/http/serverRequest.ts

@@ -61,7 +61,7 @@ export const searchParamsFromURL = (url: URL): ReadonlyRecord<string, string | A
 }
 
 /** @internal */
-export const schemaCookies = <R, I extends Readonly<Record<string, string>>, A>(
+export const schemaCookies = <A, I extends Readonly<Record<string, string>>, R>(
   schema: Schema.Schema<A, I, R>,
   options?: ParseOptions | undefined
 ) => {
@@ -70,7 +70,7 @@ export const schemaCookies = <R, I extends Readonly<Record<string, string>>, A>(
 }
 
 /** @internal */
-export const schemaHeaders = <R, I extends Readonly<Record<string, string>>, A>(
+export const schemaHeaders = <A, I extends Readonly<Record<string, string>>, R>(
   schema: Schema.Schema<A, I, R>,
   options?: ParseOptions | undefined
 ) => {
@@ -79,7 +79,7 @@ export const schemaHeaders = <R, I extends Readonly<Record<string, string>>, A>(
 }
 
 /** @internal */
-export const schemaSearchParams = <R, I extends Readonly<Record<string, string | Array<string> | undefined>>, A>(
+export const schemaSearchParams = <A, I extends Readonly<Record<string, string | Array<string> | undefined>>, R>(
   schema: Schema.Schema<A, I, R>,
   options?: ParseOptions | undefined
 ) => {
@@ -97,7 +97,7 @@ const isMultipart = (request: ServerRequest.ServerRequest) =>
   request.headers["content-type"]?.toLowerCase().includes("multipart/form-data")
 
 /** @internal */
-export const schemaBodyForm = <R, I extends Partial<Multipart.Persisted>, A>(
+export const schemaBodyForm = <A, I extends Partial<Multipart.Persisted>, R>(
   schema: Schema.Schema<A, I, R>,
   options?: ParseOptions | undefined
 ) => {
@@ -116,7 +116,7 @@ export const schemaBodyForm = <R, I extends Partial<Multipart.Persisted>, A>(
 }
 
 /** @internal */
-export const schemaBodyUrlParams = <R, I extends Readonly<Record<string, string>>, A>(
+export const schemaBodyUrlParams = <A, I extends Readonly<Record<string, string>>, R>(
   schema: Schema.Schema<A, I, R>,
   options?: ParseOptions | undefined
 ) => {
@@ -125,7 +125,7 @@ export const schemaBodyUrlParams = <R, I extends Readonly<Record<string, string>
 }
 
 /** @internal */
-export const schemaBodyMultipart = <R, I extends Partial<Multipart.Persisted>, A>(
+export const schemaBodyMultipart = <A, I extends Partial<Multipart.Persisted>, R>(
   schema: Schema.Schema<A, I, R>,
   options?: ParseOptions | undefined
 ) => {

package/src/internal/keyValueStore.ts

@@ -71,7 +71,7 @@ export const SchemaStoreTypeId: KeyValueStore.SchemaStoreTypeId = Symbol.for(
 const makeSchemaStore = <A, I, R>(
   store: KeyValueStore.KeyValueStore,
   schema: Schema.Schema<A, I, R>
-): KeyValueStore.SchemaStore<R, A> => {
+): KeyValueStore.SchemaStore<A, R> => {
   const jsonSchema = Schema.parseJson(schema)
   const parse = Schema.decodeUnknown(jsonSchema)
   const encode = Schema.encode(jsonSchema)
@@ -170,7 +170,7 @@ export const layerSchema = <A, I, R>(
   schema: Schema.Schema<A, I, R>,
   tagIdentifier: string
 ) => {
-  const tag = Context.GenericTag<KeyValueStore.SchemaStore<R, A>>(tagIdentifier)
+  const tag = Context.GenericTag<KeyValueStore.SchemaStore<A, R>>(tagIdentifier)
   const layer = Layer.effect(tag, Effect.map(keyValueStoreTag, (store) => store.forSchema(schema)))
   return { tag, layer } as const
 }

package/src/internal/worker.ts

@@ -75,7 +75,7 @@ export const makeManager = Effect.gen(function*() {
         const spawn = yield* _(Spawner)
         const id = idCounter++
         let requestIdCounter = 0
-        const semaphore = yield* Effect.makeSemaphore(permits)
+        const semaphore = Effect.unsafeMakeSemaphore(permits)
         const requestMap = new Map<
           number,
           readonly [Queue.Queue<Exit.Exit<ReadonlyArray<O>, E | WorkerError>>, Deferred.Deferred<void>]
@@ -238,7 +238,7 @@ export const makeManager = Effect.gen(function*() {
           )
 
         yield* semaphore.take(1).pipe(
-          Effect.zipRight(outbound.take),
+          Effect.andThen(outbound.take),
           Effect.flatMap(([id, request, span]) =>
             pipe(
               Effect.suspend(() => {
@@ -299,17 +299,11 @@ export const makePool = <I, O, E>(
       Effect.tap((worker) => Effect.addFinalizer(() => Effect.sync(() => workers.delete(worker)))),
       options.onCreate ? Effect.tap(options.onCreate) : identity
     )
-    const backing = yield* "timeToLive" in options ?
-      Pool.makeWithTTL({
-        acquire,
-        min: options.minSize,
-        max: options.maxSize,
-        timeToLive: options.timeToLive
-      }) :
-      Pool.make({
-        acquire,
-        size: options.size
-      })
+    const backing = yield* Pool.make({
+      acquire,
+      size: options.size
+    })
+    const get = Effect.scoped(backing.get)
     const pool: Worker.WorkerPool<I, O, E> = {
       backing,
       broadcast: (message: I) =>
@@ -317,20 +311,13 @@ export const makePool = <I, O, E>(
           concurrency: "unbounded",
           discard: true
         }),
-      execute: (message: I) =>
-        Stream.unwrap(
-          Effect.map(
-            Effect.scoped(backing.get),
-            (worker) => worker.execute(message)
-          )
-        ),
-      executeEffect: (message: I) =>
-        Effect.flatMap(
-          Effect.scoped(backing.get),
-          (worker) => worker.executeEffect(message)
-        )
+      execute: (message: I) => Stream.unwrap(Effect.map(get, (worker) => worker.execute(message))),
+      executeEffect: (message: I) => Effect.flatMap(get, (worker) => worker.executeEffect(message))
     }
 
+    // report any spawn errors
+    yield* get
+
     return pool
   })
 
@@ -410,6 +397,7 @@ export const makePoolSerialized = <I extends Schema.TaggedRequest.Any>(
         acquire,
         size: options.size
       })
+    const get = Effect.scoped(backing.get)
     const pool: Worker.SerializedWorkerPool<I> = {
       backing,
       broadcast: <Req extends I>(message: Req) =>
@@ -418,19 +406,14 @@ export const makePoolSerialized = <I extends Schema.TaggedRequest.Any>(
           discard: true
         }) as any,
       execute: <Req extends I>(message: Req) =>
-        Stream.unwrap(
-          Effect.map(
-            Effect.scoped(backing.get),
-            (worker) => worker.execute(message)
-          )
-        ) as any,
+        Stream.unwrap(Effect.map(get, (worker) => worker.execute(message))) as any,
       executeEffect: <Req extends I>(message: Req) =>
-        Effect.flatMap(
-          Effect.scoped(backing.get),
-          (worker) => worker.executeEffect(message)
-        ) as any
+        Effect.flatMap(get, (worker) => worker.executeEffect(message)) as any
     }
 
+    // report any spawn errors
+    yield* get
+
     return pool
   })