@effect/platform 0.47.1 → 0.48.1

package/src/Socket.ts

@@ -5,27 +5,30 @@ import * as Cause from "effect/Cause"
 import * as Channel from "effect/Channel"
 import * as Chunk from "effect/Chunk"
 import * as Context from "effect/Context"
-import * as Data from "effect/Data"
+import type { DurationInput } from "effect/Duration"
 import * as Effect from "effect/Effect"
 import * as Exit from "effect/Exit"
+import * as Fiber from "effect/Fiber"
 import * as FiberSet from "effect/FiberSet"
 import * as Layer from "effect/Layer"
+import * as Predicate from "effect/Predicate"
 import * as Queue from "effect/Queue"
 import * as Scope from "effect/Scope"
 import type * as AsyncProducer from "effect/SingleProducerAsyncInput"
 import IsoWebSocket from "isomorphic-ws"
+import { RefailError, TypeIdError } from "./Error.js"
 
 /**
  * @since 1.0.0
  * @category type ids
  */
-export const SocketTypeId = Symbol.for("@effect/platform/Socket")
+export const TypeId = Symbol.for("@effect/platform/Socket")
 
 /**
  * @since 1.0.0
  * @category type ids
  */
-export type SocketTypeId = typeof SocketTypeId
+export type TypeId = typeof TypeId
 
 /**
  * @since 1.0.0
@@ -40,26 +43,117 @@ export const Socket: Context.Tag<Socket, Socket> = Context.GenericTag<Socket>(
  * @category models
  */
 export interface Socket {
-  readonly [SocketTypeId]: SocketTypeId
+  readonly [TypeId]: TypeId
   readonly run: <R, E, _>(
     handler: (_: Uint8Array) => Effect.Effect<_, E, R>
   ) => Effect.Effect<void, SocketError | E, R>
-  readonly writer: Effect.Effect<(chunk: Uint8Array) => Effect.Effect<void>, never, Scope.Scope>
+  readonly writer: Effect.Effect<(chunk: Uint8Array | CloseEvent) => Effect.Effect<void>, never, Scope.Scope>
 }
 
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export const CloseEventTypeId = Symbol.for("@effect/platform/Socket/CloseEvent")
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export type CloseEventTypeId = typeof CloseEventTypeId
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export class CloseEvent {
+  /**
+   * @since 1.0.0
+   */
+  readonly [CloseEventTypeId]: CloseEventTypeId
+  constructor(readonly code = 1000, readonly reason?: string) {
+    this[CloseEventTypeId] = CloseEventTypeId
+  }
+  /**
+   * @since 1.0.0
+   */
+  toString() {
+    return this.reason ? `${this.code}: ${this.reason}` : `${this.code}`
+  }
+}
+
+/**
+ * @since 1.0.0
+ * @category refinements
+ */
+export const isCloseEvent = (u: unknown): u is CloseEvent => Predicate.hasProperty(u, CloseEventTypeId)
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export const SocketErrorTypeId = Symbol.for("@effect/platform/Socket/SocketError")
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export type SocketErrorTypeId = typeof SocketErrorTypeId
+
+/**
+ * @since 1.0.0
+ * @category refinements
+ */
+export const isSocketError = (u: unknown): u is SocketError => Predicate.hasProperty(u, SocketErrorTypeId)
+
 /**
  * @since 1.0.0
  * @category errors
  */
-export class SocketError extends Data.TaggedError("SocketError")<{
-  readonly reason: "Write" | "Read" | "Open" | "Close"
-  readonly error: unknown
+export type SocketError = SocketGenericError | SocketCloseError
+
+/**
+ * @since 1.0.0
+ * @category errors
+ */
+export class SocketGenericError extends RefailError(SocketErrorTypeId, "SocketError")<{
+  readonly reason: "Write" | "Read" | "Open" | "OpenTimeout"
+}> {
+  get message() {
+    return `${this.reason}: ${super.message}`
+  }
+}
+
+/**
+ * @since 1.0.0
+ * @category errors
+ */
+export class SocketCloseError extends TypeIdError(SocketErrorTypeId, "SocketError")<{
+  readonly reason: "Close"
+  readonly code: number
+  readonly closeReason?: string
 }> {
   /**
    * @since 1.0.0
    */
-  toString(): string {
-    return `SocketError: ${this.reason} - ${this.error}`
+  static is(u: unknown): u is SocketCloseError {
+    return isSocketError(u) && u.reason === "Close"
+  }
+
+  /**
+   * @since 1.0.0
+   */
+  static isClean(isClean: (code: number) => boolean) {
+    return function(u: unknown): u is SocketCloseError {
+      return SocketCloseError.is(u) && isClean(u.code)
+    }
+  }
+
+  get message() {
+    if (this.closeReason) {
+      return `${this.reason}: ${this.code}: ${this.closeReason}`
+    }
+    return `${this.reason}: ${this.code}`
   }
 }
 
@@ -69,14 +163,21 @@ export class SocketError extends Data.TaggedError("SocketError")<{
  */
 export const toChannel = <IE>(
   self: Socket
-): Channel.Channel<Chunk.Chunk<Uint8Array>, Chunk.Chunk<Uint8Array>, SocketError | IE, IE, void, unknown> =>
+): Channel.Channel<
+  Chunk.Chunk<Uint8Array>,
+  Chunk.Chunk<Uint8Array | CloseEvent>,
+  SocketError | IE,
+  IE,
+  void,
+  unknown
+> =>
   Channel.unwrap(
     Effect.gen(function*(_) {
       const writeScope = yield* _(Scope.make())
       const write = yield* _(Scope.extend(self.writer, writeScope))
       const exitQueue = yield* _(Queue.unbounded<Exit.Exit<Chunk.Chunk<Uint8Array>, SocketError | IE>>())
 
-      const input: AsyncProducer.AsyncInputProducer<IE, Chunk.Chunk<Uint8Array>, unknown> = {
+      const input: AsyncProducer.AsyncInputProducer<IE, Chunk.Chunk<Uint8Array | CloseEvent>, unknown> = {
         awaitRead: () => Effect.unit,
         emit(chunk) {
           return Effect.catchAllCause(
@@ -123,8 +224,14 @@ export const toChannel = <IE>(
 export const toChannelWith = <IE = never>() =>
 (
   self: Socket
-): Channel.Channel<Chunk.Chunk<Uint8Array>, Chunk.Chunk<Uint8Array>, SocketError | IE, IE, void, unknown> =>
-  toChannel(self)
+): Channel.Channel<
+  Chunk.Chunk<Uint8Array>,
+  Chunk.Chunk<Uint8Array | CloseEvent>,
+  SocketError | IE,
+  IE,
+  void,
+  unknown
+> => toChannel(self)
 
 /**
  * @since 1.0.0
@@ -132,7 +239,7 @@ export const toChannelWith = <IE = never>() =>
  */
 export const makeChannel = <IE = never>(): Channel.Channel<
   Chunk.Chunk<Uint8Array>,
-  Chunk.Chunk<Uint8Array>,
+  Chunk.Chunk<Uint8Array | CloseEvent>,
   SocketError | IE,
   IE,
   void,
@@ -167,6 +274,7 @@ export const WebSocket: Context.Tag<WebSocket, globalThis.WebSocket> = Context.G
  */
 export const makeWebSocket = (url: string | Effect.Effect<string>, options?: {
   readonly closeCodeIsError?: (code: number) => boolean
+  readonly openTimeout?: DurationInput
 }): Effect.Effect<Socket> =>
   fromWebSocket(
     Effect.acquireRelease(
@@ -190,11 +298,12 @@ export const fromWebSocket = (
   acquire: Effect.Effect<globalThis.WebSocket, SocketError, Scope.Scope>,
   options?: {
     readonly closeCodeIsError?: (code: number) => boolean
+    readonly openTimeout?: DurationInput
   }
 ): Effect.Effect<Socket> =>
   Effect.gen(function*(_) {
     const closeCodeIsError = options?.closeCodeIsError ?? defaultCloseCodeIsError
-    const sendQueue = yield* _(Queue.unbounded<Uint8Array>())
+    const sendQueue = yield* _(Queue.unbounded<Uint8Array | CloseEvent>())
 
     const run = <R, E, _>(handler: (_: Uint8Array) => Effect.Effect<_, E, R>) =>
       Effect.gen(function*(_) {
@@ -219,23 +328,38 @@ export const fromWebSocket = (
         }
 
         if (ws.readyState !== IsoWebSocket.OPEN) {
-          yield* _(Effect.async<void, SocketError, never>((resume) => {
-            ws.onopen = () => {
-              resume(Effect.unit)
-            }
-            ws.onerror = (error_) => {
-              resume(Effect.fail(new SocketError({ reason: "Open", error: (error_ as any).message })))
-            }
-          }))
+          yield* _(
+            Effect.async<void, SocketError, never>((resume) => {
+              ws.onopen = () => {
+                resume(Effect.unit)
+              }
+              ws.onerror = (error_) => {
+                resume(Effect.fail(new SocketGenericError({ reason: "Open", error: (error_ as any).message })))
+              }
+            }),
+            Effect.timeoutFail({
+              duration: options?.openTimeout ?? 10000,
+              onTimeout: () => new SocketGenericError({ reason: "OpenTimeout", error: "timeout waiting for \"open\"" })
+            })
+          )
         }
 
-        yield* _(
+        const writeFiber = yield* _(
           Queue.take(sendQueue),
           Effect.tap((chunk) =>
-            Effect.try({
-              try: () => ws.send(chunk),
-              catch: (error) => Effect.fail(new SocketError({ reason: "Write", error: (error as any).message }))
-            })
+            isCloseEvent(chunk) ?
+              Effect.failSync(() => {
+                ws.close(chunk.code, chunk.reason)
+                return new SocketCloseError({
+                  reason: "Close",
+                  code: chunk.code,
+                  closeReason: chunk.reason
+                })
+              }) :
+              Effect.try({
+                try: () => ws.send(chunk),
+                catch: (error) => new SocketGenericError({ reason: "Write", error: (error as any).message })
+              })
           ),
           Effect.forever,
           Effect.fork
@@ -244,25 +368,34 @@ export const fromWebSocket = (
         yield* _(
           Effect.async<void, SocketError, never>((resume) => {
             ws.onclose = (event) => {
-              if (closeCodeIsError(event.code)) {
-                resume(Effect.fail(new SocketError({ reason: "Close", error: event })))
-              } else {
-                resume(Effect.unit)
-              }
+              resume(
+                Effect.fail(
+                  new SocketCloseError({
+                    reason: "Close",
+                    code: event.code,
+                    closeReason: event.reason
+                  })
+                )
+              )
             }
             ws.onerror = (error) => {
-              resume(Effect.fail(new SocketError({ reason: "Read", error: (error as any).message })))
+              resume(Effect.fail(new SocketGenericError({ reason: "Read", error: (error as any).message })))
             }
           }),
-          Effect.raceFirst(FiberSet.join(fiberSet))
+          Effect.raceFirst(FiberSet.join(fiberSet)),
+          Effect.raceFirst(Fiber.join(writeFiber)),
+          Effect.catchIf(
+            SocketCloseError.isClean((_) => !closeCodeIsError(_)),
+            (_) => Effect.unit
+          )
         )
       }).pipe(Effect.scoped)
 
-    const write = (chunk: Uint8Array) => Queue.offer(sendQueue, chunk)
+    const write = (chunk: Uint8Array | CloseEvent) => Queue.offer(sendQueue, chunk)
     const writer = Effect.succeed(write)
 
     return Socket.of({
-      [SocketTypeId]: SocketTypeId,
+      [TypeId]: TypeId,
       run,
       writer
     })
@@ -277,7 +410,14 @@ export const makeWebSocketChannel = <IE = never>(
   options?: {
     readonly closeCodeIsError?: (code: number) => boolean
   }
-): Channel.Channel<Chunk.Chunk<Uint8Array>, Chunk.Chunk<Uint8Array>, SocketError | IE, IE, void, unknown> =>
+): Channel.Channel<
+  Chunk.Chunk<Uint8Array>,
+  Chunk.Chunk<Uint8Array | CloseEvent>,
+  SocketError | IE,
+  IE,
+  void,
+  unknown
+> =>
   Channel.unwrapScoped(
     Effect.map(makeWebSocket(url, options), toChannelWith<IE>())
   )

package/src/Transferable.ts

@@ -91,7 +91,7 @@ export const schema: {
   f: (_: I) => Iterable<globalThis.Transferable>
 ) =>
   Schema.transformOrFail(
-    Schema.from(self),
+    Schema.encodedSchema(self),
     self,
     ParseResult.succeed,
     (i) => Effect.as(addAll(f(i)), i)

package/src/Worker.ts

@@ -134,7 +134,7 @@ export declare namespace Worker {
     | readonly [id: number, end: 1]
     | readonly [id: number, end: 1, ReadonlyArray<O>]
     | readonly [id: number, error: 2, E]
-    | readonly [id: number, defect: 3, Schema.CauseFrom<WorkerErrorFrom>]
+    | readonly [id: number, defect: 3, Schema.CauseEncoded<WorkerErrorFrom>]
 }
 
 /**
@@ -246,12 +246,12 @@ export interface SerializedWorker<I extends Schema.TaggedRequest.Any> {
   readonly id: number
   readonly execute: <Req extends I>(
     message: Req
-  ) => Req extends Serializable.WithResult<infer R, infer _IE, infer E, infer _IA, infer A>
+  ) => Req extends Serializable.WithResult<infer A, infer _I, infer E, infer _EI, infer R>
     ? Stream.Stream<A, E | WorkerError | ParseResult.ParseError, R>
     : never
   readonly executeEffect: <Req extends I>(
     message: Req
-  ) => Req extends Serializable.WithResult<infer R, infer _IE, infer E, infer _IA, infer A>
+  ) => Req extends Serializable.WithResult<infer A, infer _I, infer E, infer _EI, infer R>
     ? Effect.Effect<A, E | WorkerError | ParseResult.ParseError, R>
     : never
 }
@@ -290,17 +290,17 @@ export interface SerializedWorkerPool<I extends Schema.TaggedRequest.Any> {
   readonly backing: Pool.Pool<SerializedWorker<I>, WorkerError>
   readonly broadcast: <Req extends I>(
     message: Req
-  ) => Req extends Serializable.WithResult<infer R, infer _IE, infer E, infer _IA, infer _A>
+  ) => Req extends Serializable.WithResult<infer _A, infer _I, infer E, infer _EI, infer R>
     ? Effect.Effect<void, E | WorkerError | ParseResult.ParseError, R>
     : never
   readonly execute: <Req extends I>(
     message: Req
-  ) => Req extends Serializable.WithResult<infer R, infer _IE, infer E, infer _IA, infer A>
+  ) => Req extends Serializable.WithResult<infer A, infer _I, infer E, infer _EI, infer R>
     ? Stream.Stream<A, E | WorkerError | ParseResult.ParseError, R>
     : never
   readonly executeEffect: <Req extends I>(
     message: Req
-  ) => Req extends Serializable.WithResult<infer R, infer _IE, infer E, infer _IA, infer A>
+  ) => Req extends Serializable.WithResult<infer A, infer _I, infer E, infer _EI, infer R>
     ? Effect.Effect<A, E | WorkerError | ParseResult.ParseError, R>
     : never
 }

package/src/WorkerError.ts

@@ -55,22 +55,24 @@ export class WorkerError extends Schema.TaggedError<WorkerError>()("WorkerError"
    */
   static readonly Cause: Schema.Schema<
     Cause.Cause<WorkerError>,
-    Schema.CauseFrom<WorkerErrorFrom>
+    Schema.CauseEncoded<WorkerErrorFrom>
   > = Schema.cause({ defect: causeDefectPretty, error: this })
 
   /**
    * @since 1.0.0
    */
-  static readonly encodeCause: (a: Cause.Cause<WorkerError>) => Schema.CauseFrom<WorkerErrorFrom> = Schema.encodeSync(
-    this.Cause
-  )
+  static readonly encodeCause: (a: Cause.Cause<WorkerError>) => Schema.CauseEncoded<WorkerErrorFrom> = Schema
+    .encodeSync(
+      this.Cause
+    )
 
   /**
    * @since 1.0.0
    */
-  static readonly decodeCause: (u: Schema.CauseFrom<WorkerErrorFrom>) => Cause.Cause<WorkerError> = Schema.decodeSync(
-    this.Cause
-  )
+  static readonly decodeCause: (u: Schema.CauseEncoded<WorkerErrorFrom>) => Cause.Cause<WorkerError> = Schema
+    .decodeSync(
+      this.Cause
+    )
 
   /**
    * @since 1.0.0

package/src/WorkerRunner.ts

@@ -121,19 +121,19 @@ export declare namespace SerializedRunner {
       A,
       { readonly _tag: K }
     > extends Serializable.SerializableWithResult<
-      infer _RS,
-      infer _IS,
       infer S,
-      infer _RR,
-      infer _IE,
+      infer _SI,
+      infer _SR,
+      infer A,
+      infer _AI,
       infer E,
-      infer _IO,
-      infer O
+      infer _EI,
+      infer _RR
     > ? (
         _: S
       ) =>
-        | Stream.Stream<O, E, any>
-        | Effect.Effect<O, E, any>
+        | Stream.Stream<A, E, any>
+        | Effect.Effect<A, E, any>
         | Layer.Layer<any, E, any>
         | Layer.Layer<never, E, any>
       : never

package/src/internal/http/multipart.ts

@@ -23,6 +23,19 @@ import * as Path from "../../Path.js"
 /** @internal */
 export const TypeId: Multipart.TypeId = Symbol.for("@effect/platform/Http/Multipart") as Multipart.TypeId
 
+/** @internal */
+export const isPart = (u: unknown): u is Multipart.Part => Predicate.hasProperty(u, TypeId)
+
+/** @internal */
+export const isField = (u: unknown): u is Multipart.Field => isPart(u) && u._tag === "Field"
+
+/** @internal */
+export const isFile = (u: unknown): u is Multipart.File => isPart(u) && u._tag === "File"
+
+/** @internal */
+export const isPersistedFile = (u: unknown): u is Multipart.PersistedFile =>
+  Predicate.hasProperty(u, TypeId) && Predicate.isTagged(u, "PersistedFile")
+
 /** @internal */
 export const ErrorTypeId: Multipart.ErrorTypeId = Symbol.for(
   "@effect/platform/Http/Multipart/MultipartError"
@@ -37,10 +50,6 @@ export const MultipartError = (reason: Multipart.MultipartError["reason"], error
     error
   })
 
-/** @internal */
-export const isField = (u: unknown): u is Multipart.Field =>
-  Predicate.hasProperty(u, TypeId) && Predicate.isTagged(u, "Field")
-
 /** @internal */
 export const maxParts: FiberRef.FiberRef<Option.Option<number>> = globalValue(
   "@effect/platform/Http/Multipart/maxParts",
@@ -89,20 +98,15 @@ export const withFieldMimeTypes = dual<
   <R, E, A>(effect: Effect.Effect<A, E, R>, mimeTypes: ReadonlyArray<string>) => Effect.Effect<A, E, R>
 >(2, (effect, mimeTypes) => Effect.locally(effect, fieldMimeTypes, Chunk.fromIterable(mimeTypes)))
 
-const fileSchema: Schema.Schema<Multipart.PersistedFile> = Schema.struct({
-  [TypeId]: Schema.uniqueSymbol(TypeId),
-  _tag: Schema.literal("PersistedFile"),
-  key: Schema.string,
-  name: Schema.string,
-  contentType: Schema.string,
-  path: Schema.string
+const fileSchema: Schema.Schema<Multipart.PersistedFile> = Schema.declare(isPersistedFile, {
+  identifier: "PersistedFile"
 })
 
 /** @internal */
 export const filesSchema: Schema.Schema<ReadonlyArray<Multipart.PersistedFile>> = Schema.array(fileSchema)
 
 /** @internal */
-export const schemaPersisted = <R, I extends Multipart.Persisted, A>(
+export const schemaPersisted = <R, I extends Partial<Multipart.Persisted>, A>(
   schema: Schema.Schema<A, I, R>
 ) => {
   const parse = Schema.decodeUnknown(schema)

package/src/internal/http/serverRequest.ts

@@ -48,7 +48,7 @@ const isMultipart = (request: ServerRequest.ServerRequest) =>
   request.headers["content-type"]?.toLowerCase().includes("multipart/form-data")
 
 /** @internal */
-export const schemaBodyForm = <R, I extends Multipart.Persisted, A>(
+export const schemaBodyForm = <R, I extends Partial<Multipart.Persisted>, A>(
   schema: Schema.Schema<A, I, R>
 ) => {
   const parseMultipart = Multipart.schemaPersisted(schema)
@@ -74,7 +74,7 @@ export const schemaBodyUrlParams = <R, I extends Readonly<Record<string, string>
 }
 
 /** @internal */
-export const schemaBodyMultipart = <R, I extends Multipart.Persisted, A>(
+export const schemaBodyMultipart = <R, I extends Partial<Multipart.Persisted>, A>(
   schema: Schema.Schema<A, I, R>
 ) => {
   const parse = Multipart.schemaPersisted(schema)