@effect/platform 0.47.0 → 0.48.0

package/src/Http/Multipart.ts

@@ -33,6 +33,12 @@ export type TypeId = typeof TypeId
  */
 export type Part = Field | File
 
+/**
+ * @since 1.0.0
+ * @category refinements
+ */
+export const isPart: (u: unknown) => u is Part = internal.isPart
+
 /**
  * @since 1.0.0
  */
@@ -58,6 +64,12 @@ export interface Field extends Part.Proto {
   readonly value: string
 }
 
+/**
+ * @since 1.0.0
+ * @category refinements
+ */
+export const isField: (u: unknown) => u is Field = internal.isField
+
 /**
  * @since 1.0.0
  * @category models
@@ -70,6 +82,12 @@ export interface File extends Part.Proto {
   readonly content: Stream.Stream<Uint8Array, MultipartError>
 }
 
+/**
+ * @since 1.0.0
+ * @category refinements
+ */
+export const isFile: (u: unknown) => u is File = internal.isFile
+
 /**
  * @since 1.0.0
  * @category models
@@ -82,6 +100,12 @@ export interface PersistedFile extends Part.Proto {
   readonly path: string
 }
 
+/**
+ * @since 1.0.0
+ * @category refinements
+ */
+export const isPersistedFile: (u: unknown) => u is PersistedFile = internal.isPersistedFile
+
 /**
  * @since 1.0.0
  * @category models
@@ -122,12 +146,6 @@ export const MultipartError: (
   error: unknown
 ) => MultipartError = internal.MultipartError
 
-/**
- * @since 1.0.0
- * @category refinements
- */
-export const isField: (u: unknown) => u is Field = internal.isField
-
 /**
  * @since 1.0.0
  * @category fiber refs
@@ -209,7 +227,7 @@ export const schemaJson: <A, I, R>(
  * @since 1.0.0
  * @category schema
  */
-export const schemaPersisted: <R, I extends Persisted, A>(
+export const schemaPersisted: <R, I extends Partial<Persisted>, A>(
   schema: Schema.Schema<A, I, R>
 ) => (persisted: Persisted) => Effect.Effect<A, ParseResult.ParseError, R> = internal.schemaPersisted
 

package/src/Http/ServerError.ts

@@ -3,6 +3,7 @@
  */
 import type * as Cause from "effect/Cause"
 import type * as FiberId from "effect/FiberId"
+import { RefailError, TypeIdError } from "../Error.js"
 import * as internal from "../internal/http/serverError.js"
 import type * as ServerRequest from "./ServerRequest.js"
 import type * as ServerResponse from "./ServerResponse.js"
@@ -25,34 +26,21 @@ export type TypeId = typeof TypeId
  */
 export type HttpServerError = RequestError | ResponseError | RouteNotFound | ServeError
 
-/**
- * @since 1.0.0
- */
-export declare namespace HttpError {
-  /**
-   * @since 1.0.0
-   * @category models
-   */
-  export interface Proto {
-    readonly [TypeId]: TypeId
-    readonly _tag: string
-  }
-
-  /**
-   * @since 1.0.0
-   */
-  export type ProvidedFields = TypeId | "_tag"
-}
-
 /**
  * @since 1.0.0
  * @category error
  */
-export interface RequestError extends HttpError.Proto {
-  readonly _tag: "RequestError"
+export class RequestError extends RefailError(TypeId, "RequestError")<{
   readonly request: ServerRequest.ServerRequest
   readonly reason: "Transport" | "Decode"
-  readonly error: unknown
+}> {
+  get methodAndUrl() {
+    return `${this.request.method} ${this.request.url}`
+  }
+
+  get message() {
+    return `${this.reason} error (${this.methodAndUrl}): ${super.message}`
+  }
 }
 
 /**
@@ -65,57 +53,38 @@ export const isServerError: (u: unknown) => u is HttpServerError = internal.isSe
  * @since 1.0.0
  * @category error
  */
-export const RequestError: (props: Omit<RequestError, HttpError.ProvidedFields>) => RequestError = internal.requestError
-
-/**
- * @since 1.0.0
- * @category error
- */
-export interface RouteNotFound extends HttpError.Proto {
-  readonly _tag: "RouteNotFound"
+export class RouteNotFound extends TypeIdError(TypeId, "RouteNotFound")<{
   readonly request: ServerRequest.ServerRequest
+}> {
+  get message() {
+    return `${this.request.method} ${this.request.url} not found`
+  }
 }
 
 /**
  * @since 1.0.0
  * @category error
  */
-export const RouteNotFound: (props: Omit<RouteNotFound, HttpError.ProvidedFields>) => RouteNotFound =
-  internal.routeNotFound
-
-/**
- * @since 1.0.0
- * @category error
- */
-export interface ResponseError extends HttpError.Proto {
-  readonly _tag: "ResponseError"
+export class ResponseError extends RefailError(TypeId, "ResponseError")<{
   readonly request: ServerRequest.ServerRequest
   readonly response: ServerResponse.ServerResponse
   readonly reason: "Decode"
-  readonly error: unknown
-}
-
-/**
- * @since 1.0.0
- * @category error
- */
-export const ResponseError: (props: Omit<ResponseError, HttpError.ProvidedFields>) => ResponseError =
-  internal.responseError
+}> {
+  get methodAndUrl() {
+    return `${this.request.method} ${this.request.url}`
+  }
 
-/**
- * @since 1.0.0
- * @category error
- */
-export interface ServeError extends HttpError.Proto {
-  readonly _tag: "ServeError"
-  readonly error: unknown
+  get message() {
+    return `${this.reason} error (${this.response.status} ${this.methodAndUrl}): ${super.message}`
+  }
 }
 
 /**
  * @since 1.0.0
  * @category error
  */
-export const ServeError: (props: Omit<ServeError, HttpError.ProvidedFields>) => ServeError = internal.serveError
+export class ServeError extends RefailError(TypeId, "ServeError")<{}> {
+}
 
 /**
  * @since 1.0.0

package/src/Http/ServerRequest.ts

@@ -96,7 +96,7 @@ export const upgrade: Effect.Effect<Socket.Socket, Error.RequestError, ServerReq
  */
 export const upgradeChannel: <IE = never>() => Channel<
   Chunk<Uint8Array>,
-  Chunk<Uint8Array>,
+  Chunk<Uint8Array | Socket.CloseEvent>,
   Error.RequestError | IE | Socket.SocketError,
   IE,
   void,
@@ -124,12 +124,12 @@ export const schemaBodyJson: <A, I, R>(
  * @since 1.0.0
  * @category schema
  */
-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>
 ) => Effect.Effect<
   A,
-  Multipart.MultipartError | Error.RequestError | ParseResult.ParseError,
-  ServerRequest | Scope.Scope | FileSystem.FileSystem | Path.Path | R
+  Multipart.MultipartError | ParseResult.ParseError | Error.RequestError,
+  R | ServerRequest | Scope.Scope | FileSystem.FileSystem | Path.Path
 > = internal.schemaBodyForm
 
 /**
@@ -144,7 +144,7 @@ export const schemaBodyUrlParams: <R, I extends Readonly<Record<string, string>>
  * @since 1.0.0
  * @category schema
  */
-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>
 ) => Effect.Effect<
   A,

package/src/Http/UrlParams.ts

@@ -31,6 +31,16 @@ export const fromInput = (input: Input): UrlParams => {
   return ReadonlyArray.fromIterable(Object.entries(input))
 }
 
+/**
+ * @since 1.0.0
+ * @category schemas
+ */
+export const schema: Schema.Schema<UrlParams, ReadonlyArray<readonly [string, string]>> = Schema.array(
+  Schema.tuple(Schema.string, Schema.string)
+).pipe(
+  Schema.identifier("UrlParams")
+)
+
 /**
  * @since 1.0.0
  * @category constructors

package/src/PlatformLogger.ts

@@ -19,7 +19,7 @@ import * as internal from "./internal/platformLogger.js"
  * import { Effect, Layer, Logger } from "effect"
  *
  * const fileLogger = Logger.logfmtLogger.pipe(
- *   PlatformLogger.toFile("log.txt")
+ *   PlatformLogger.toFile("/tmp/log.txt")
  * )
  * const LoggerLive = Logger.replaceScoped(Logger.defaultLogger, fileLogger).pipe(
  *   Layer.provide(NodeFileSystem.layer)

package/src/Runtime.ts

@@ -31,6 +31,9 @@ export const defaultTeardown: Teardown = <E, A>(
 export interface RunMain {
   <E, A>(
     effect: Effect.Effect<A, E>,
-    teardown?: Teardown
+    options?: {
+      readonly disableErrorReporting?: boolean
+      readonly teardown?: Teardown
+    }
   ): void
 }

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
 }