@effect/platform 0.46.3 → 0.47.1

package/src/Socket.ts

@@ -0,0 +1,291 @@
+/**
+ * @since 1.0.0
+ */
+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 * as Effect from "effect/Effect"
+import * as Exit from "effect/Exit"
+import * as FiberSet from "effect/FiberSet"
+import * as Layer from "effect/Layer"
+import * as Queue from "effect/Queue"
+import * as Scope from "effect/Scope"
+import type * as AsyncProducer from "effect/SingleProducerAsyncInput"
+import IsoWebSocket from "isomorphic-ws"
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export const SocketTypeId = Symbol.for("@effect/platform/Socket")
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export type SocketTypeId = typeof SocketTypeId
+
+/**
+ * @since 1.0.0
+ * @category tags
+ */
+export const Socket: Context.Tag<Socket, Socket> = Context.GenericTag<Socket>(
+  "@effect/platform/Socket"
+)
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface Socket {
+  readonly [SocketTypeId]: SocketTypeId
+  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>
+}
+
+/**
+ * @since 1.0.0
+ * @category errors
+ */
+export class SocketError extends Data.TaggedError("SocketError")<{
+  readonly reason: "Write" | "Read" | "Open" | "Close"
+  readonly error: unknown
+}> {
+  /**
+   * @since 1.0.0
+   */
+  toString(): string {
+    return `SocketError: ${this.reason} - ${this.error}`
+  }
+}
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const toChannel = <IE>(
+  self: Socket
+): Channel.Channel<Chunk.Chunk<Uint8Array>, Chunk.Chunk<Uint8Array>, 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> = {
+        awaitRead: () => Effect.unit,
+        emit(chunk) {
+          return Effect.catchAllCause(
+            Effect.forEach(chunk, write, { discard: true }),
+            (cause) => Queue.offer(exitQueue, Exit.failCause(cause))
+          )
+        },
+        error(error) {
+          return Effect.zipRight(
+            Scope.close(writeScope, Exit.unit),
+            Queue.offer(exitQueue, Exit.failCause(error))
+          )
+        },
+        done() {
+          return Scope.close(writeScope, Exit.unit)
+        }
+      }
+
+      yield* _(
+        self.run((data) => Queue.offer(exitQueue, Exit.succeed(Chunk.of(data)))),
+        Effect.zipRight(Effect.failCause(Cause.empty)),
+        Effect.exit,
+        Effect.tap((exit) => Queue.offer(exitQueue, exit)),
+        Effect.fork
+      )
+
+      const loop: Channel.Channel<Chunk.Chunk<Uint8Array>, unknown, SocketError | IE, unknown, void, unknown> = Channel
+        .flatMap(
+          Queue.take(exitQueue),
+          Exit.match({
+            onFailure: (cause) => Cause.isEmptyType(cause) ? Channel.unit : Channel.failCause(cause),
+            onSuccess: (chunk) => Channel.zipRight(Channel.write(chunk), loop)
+          })
+        )
+
+      return Channel.embedInput(loop, input)
+    })
+  )
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const toChannelWith = <IE = never>() =>
+(
+  self: Socket
+): Channel.Channel<Chunk.Chunk<Uint8Array>, Chunk.Chunk<Uint8Array>, SocketError | IE, IE, void, unknown> =>
+  toChannel(self)
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const makeChannel = <IE = never>(): Channel.Channel<
+  Chunk.Chunk<Uint8Array>,
+  Chunk.Chunk<Uint8Array>,
+  SocketError | IE,
+  IE,
+  void,
+  unknown,
+  Socket
+> => Channel.unwrap(Effect.map(Socket, toChannelWith<IE>()))
+
+/**
+ * @since 1.0.0
+ */
+export const defaultCloseCodeIsError = (code: number) => code !== 1000 && code !== 1006
+
+/**
+ * @since 1.0.0
+ * @category tags
+ */
+export interface WebSocket {
+  readonly _: unique symbol
+}
+
+/**
+ * @since 1.0.0
+ * @category tags
+ */
+export const WebSocket: Context.Tag<WebSocket, globalThis.WebSocket> = Context.GenericTag(
+  "@effect/platform/Socket/WebSocket"
+)
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const makeWebSocket = (url: string | Effect.Effect<string>, options?: {
+  readonly closeCodeIsError?: (code: number) => boolean
+}): Effect.Effect<Socket> =>
+  fromWebSocket(
+    Effect.acquireRelease(
+      Effect.map(
+        typeof url === "string" ? Effect.succeed(url) : url,
+        (url) => {
+          const WS = "WebSocket" in globalThis ? globalThis.WebSocket : IsoWebSocket
+          return new WS(url) as globalThis.WebSocket
+        }
+      ),
+      (ws) => Effect.sync(() => ws.close())
+    ),
+    options
+  )
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const fromWebSocket = (
+  acquire: Effect.Effect<globalThis.WebSocket, SocketError, Scope.Scope>,
+  options?: {
+    readonly closeCodeIsError?: (code: number) => boolean
+  }
+): Effect.Effect<Socket> =>
+  Effect.gen(function*(_) {
+    const closeCodeIsError = options?.closeCodeIsError ?? defaultCloseCodeIsError
+    const sendQueue = yield* _(Queue.unbounded<Uint8Array>())
+
+    const run = <R, E, _>(handler: (_: Uint8Array) => Effect.Effect<_, E, R>) =>
+      Effect.gen(function*(_) {
+        const ws = yield* _(acquire)
+        const encoder = new TextEncoder()
+        const fiberSet = yield* _(FiberSet.make<any, E | SocketError>())
+        const run = yield* _(
+          FiberSet.runtime(fiberSet)<R>(),
+          Effect.provideService(WebSocket, ws)
+        )
+
+        ws.onmessage = (event) => {
+          run(
+            handler(
+              event.data instanceof Uint8Array
+                ? event.data
+                : typeof event.data === "string"
+                ? encoder.encode(event.data)
+                : new Uint8Array(event.data)
+            )
+          )
+        }
+
+        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* _(
+          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 }))
+            })
+          ),
+          Effect.forever,
+          Effect.fork
+        )
+
+        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)
+              }
+            }
+            ws.onerror = (error) => {
+              resume(Effect.fail(new SocketError({ reason: "Read", error: (error as any).message })))
+            }
+          }),
+          Effect.raceFirst(FiberSet.join(fiberSet))
+        )
+      }).pipe(Effect.scoped)
+
+    const write = (chunk: Uint8Array) => Queue.offer(sendQueue, chunk)
+    const writer = Effect.succeed(write)
+
+    return Socket.of({
+      [SocketTypeId]: SocketTypeId,
+      run,
+      writer
+    })
+  })
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const makeWebSocketChannel = <IE = never>(
+  url: string,
+  options?: {
+    readonly closeCodeIsError?: (code: number) => boolean
+  }
+): Channel.Channel<Chunk.Chunk<Uint8Array>, Chunk.Chunk<Uint8Array>, SocketError | IE, IE, void, unknown> =>
+  Channel.unwrapScoped(
+    Effect.map(makeWebSocket(url, options), toChannelWith<IE>())
+  )
+
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+export const layerWebSocket = (url: string, options?: {
+  readonly closeCodeIsError?: (code: number) => boolean
+}): Layer.Layer<Socket> => Layer.scoped(Socket, makeWebSocket(url, options))

package/src/index.ts

@@ -43,11 +43,21 @@ export * as KeyValueStore from "./KeyValueStore.js"
  */
 export * as Path from "./Path.js"
 
+/**
+ * @since 1.0.0
+ */
+export * as PlatformLogger from "./PlatformLogger.js"
+
 /**
  * @since 1.0.0
  */
 export * as Runtime from "./Runtime.js"
 
+/**
+ * @since 1.0.0
+ */
+export * as Socket from "./Socket.js"
+
 /**
  * @since 1.0.0
  */

package/src/internal/http/body.ts

@@ -48,8 +48,10 @@ class RawImpl implements Body.Raw {
 }
 
 /** @internal */
-export const raw = (body: unknown, contentType?: string, contentLength?: number): Body.Raw =>
-  new RawImpl(body, contentType, contentLength)
+export const raw = (body: unknown, options?: {
+  readonly contentType?: string
+  readonly contentLength?: number
+}): Body.Raw => new RawImpl(body, options?.contentType, options?.contentLength)
 
 class Uint8ArrayImpl implements Body.Uint8Array {
   readonly [TypeId]: Body.TypeId

package/src/internal/http/client.ts

@@ -11,13 +11,12 @@ import type * as Scope from "effect/Scope"
 import * as Stream from "effect/Stream"
 import type * as Body from "../../Http/Body.js"
 import type * as Client from "../../Http/Client.js"
-import type * as Error from "../../Http/ClientError.js"
+import * as Error from "../../Http/ClientError.js"
 import type * as ClientRequest from "../../Http/ClientRequest.js"
 import type * as ClientResponse from "../../Http/ClientResponse.js"
 import * as Method from "../../Http/Method.js"
 import * as UrlParams from "../../Http/UrlParams.js"
 import * as internalBody from "./body.js"
-import * as internalError from "./clientError.js"
 import * as internalRequest from "./clientRequest.js"
 import * as internalResponse from "./clientResponse.js"
 
@@ -82,7 +81,7 @@ export const fetch = (options?: RequestInit): Client.Client.Default =>
   makeDefault((request) =>
     Effect.flatMap(
       UrlParams.makeUrl(request.url, request.urlParams, (_) =>
-        internalError.requestError({
+        new Error.RequestError({
           request,
           reason: "InvalidUrl",
           error: _
@@ -109,7 +108,7 @@ export const fetch = (options?: RequestInit): Client.Client.Default =>
                       signal: controller.signal
                     } as any),
                   catch: (_) =>
-                    internalError.requestError({
+                    new Error.RequestError({
                       request,
                       reason: "Transport",
                       error: _
@@ -419,7 +418,7 @@ export const filterStatus = dual<
       effect,
       (response) => f(response.status),
       (response) =>
-        internalError.responseError({
+        new Error.ResponseError({
           request,
           response,
           reason: "StatusCode",
@@ -571,7 +570,7 @@ export const schemaFunction = dual<
       Effect.tryMap(encode(a), {
         try: (body) => new TextEncoder().encode(JSON.stringify(body)),
         catch: (error) =>
-          internalError.requestError({
+          new Error.RequestError({
             request,
             reason: "Encode",
             error

package/src/internal/http/clientError.ts

@@ -1,20 +1,6 @@
-import * as Data from "effect/Data"
 import type * as Error from "../../Http/ClientError.js"
 
 /** @internal */
 export const TypeId: Error.TypeId = Symbol.for(
   "@effect/platform/Http/Error"
 ) as Error.TypeId
-
-const make = <A extends Error.HttpClientError>(tag: A["_tag"]) => (props: Omit<A, Error.HttpError.ProvidedFields>): A =>
-  Data.struct({
-    [TypeId]: TypeId,
-    _tag: tag,
-    ...props
-  } as A)
-
-/** @internal */
-export const requestError = make<Error.RequestError>("RequestError")
-
-/** @internal */
-export const responseError = make<Error.ResponseError>("ResponseError")

package/src/internal/http/clientResponse.ts

@@ -3,13 +3,12 @@ import * as Schema from "@effect/schema/Schema"
 import * as Effect from "effect/Effect"
 import * as Option from "effect/Option"
 import * as Stream from "effect/Stream"
-import type * as Error from "../../Http/ClientError.js"
+import * as Error from "../../Http/ClientError.js"
 import type * as ClientRequest from "../../Http/ClientRequest.js"
 import type * as ClientResponse from "../../Http/ClientResponse.js"
 import * as Headers from "../../Http/Headers.js"
 import * as IncomingMessage from "../../Http/IncomingMessage.js"
 import * as UrlParams from "../../Http/UrlParams.js"
-import * as internalError from "./clientError.js"
 
 /** @internal */
 export const TypeId: ClientResponse.TypeId = Symbol.for("@effect/platform/Http/ClientResponse") as ClientResponse.TypeId
@@ -47,25 +46,27 @@ class ClientResponseImpl implements ClientResponse.ClientResponse {
   get stream(): Stream.Stream<Uint8Array, Error.ResponseError> {
     return this.source.body
       ? Stream.fromReadableStream(() => this.source.body!, (_) =>
-        internalError.responseError({
+        new Error.ResponseError({
           request: this.request,
           response: this,
           reason: "Decode",
           error: _
         }))
-      : Stream.fail(internalError.responseError({
-        request: this.request,
-        response: this,
-        reason: "EmptyBody",
-        error: "can not create stream from empty body"
-      }))
+      : Stream.fail(
+        new Error.ResponseError({
+          request: this.request,
+          response: this,
+          reason: "EmptyBody",
+          error: "can not create stream from empty body"
+        })
+      )
   }
 
   get json(): Effect.Effect<unknown, Error.ResponseError> {
     return Effect.tryMap(this.text, {
       try: (text) => text === "" ? null : JSON.parse(text) as unknown,
       catch: (_) =>
-        internalError.responseError({
+        new Error.ResponseError({
           request: this.request,
           response: this,
           reason: "Decode",
@@ -79,7 +80,7 @@ class ClientResponseImpl implements ClientResponse.ClientResponse {
     return this.textBody ??= Effect.tryPromise({
       try: () => this.source.text(),
       catch: (_) =>
-        internalError.responseError({
+        new Error.ResponseError({
           request: this.request,
           response: this,
           reason: "Decode",
@@ -93,7 +94,7 @@ class ClientResponseImpl implements ClientResponse.ClientResponse {
       Effect.try({
         try: () => UrlParams.fromInput(new URLSearchParams(_)),
         catch: (_) =>
-          internalError.responseError({
+          new Error.ResponseError({
             request: this.request,
             response: this,
             reason: "Decode",
@@ -107,7 +108,7 @@ class ClientResponseImpl implements ClientResponse.ClientResponse {
     return this.formDataBody ??= Effect.tryPromise({
       try: () => this.source.formData(),
       catch: (_) =>
-        internalError.responseError({
+        new Error.ResponseError({
           request: this.request,
           response: this,
           reason: "Decode",
@@ -121,7 +122,7 @@ class ClientResponseImpl implements ClientResponse.ClientResponse {
     return this.arrayBufferBody ??= Effect.tryPromise({
       try: () => this.source.arrayBuffer(),
       catch: (_) =>
-        internalError.responseError({
+        new Error.ResponseError({
           request: this.request,
           response: this,
           reason: "Decode",

package/src/internal/http/multiplex.ts

@@ -29,7 +29,7 @@ class MultiplexImpl<R, E>
     this[TypeId] = TypeId
 
     let execute: (request: ServerRequest.ServerRequest) => App.Default<R, E | Error.RouteNotFound> = (request) =>
-      Effect.fail(Error.RouteNotFound({ request }))
+      Effect.fail(new Error.RouteNotFound({ request }))
 
     for (let i = apps.length - 1; i >= 0; i--) {
       const [predicate, app] = apps[i]

package/src/internal/http/router.ts

@@ -151,7 +151,7 @@ const toHttpApp = <R, E>(
         result = router.find("GET", request.url)
       }
       if (result === undefined) {
-        return Effect.fail(Error.RouteNotFound({ request }))
+        return Effect.fail(new Error.RouteNotFound({ request }))
       }
       const route = result.handler
       if (route.prefix._tag === "Some") {

package/src/internal/http/serverError.ts

@@ -1,5 +1,4 @@
 import * as Cause from "effect/Cause"
-import * as Data from "effect/Data"
 import * as FiberId from "effect/FiberId"
 import { globalValue } from "effect/GlobalValue"
 import * as Option from "effect/Option"
@@ -11,28 +10,9 @@ export const TypeId: Error.TypeId = Symbol.for(
   "@effect/platform/Http/Error"
 ) as Error.TypeId
 
-const make = <A extends Error.HttpServerError>(tag: A["_tag"]) => (props: Omit<A, Error.HttpError.ProvidedFields>): A =>
-  Data.struct({
-    [TypeId]: TypeId,
-    _tag: tag,
-    ...props
-  } as A)
-
 /** @internal */
 export const isServerError = (u: unknown): u is Error.HttpServerError => Predicate.hasProperty(u, TypeId)
 
-/** @internal */
-export const requestError = make<Error.RequestError>("RequestError")
-
-/** @internal */
-export const responseError = make<Error.ResponseError>("ResponseError")
-
-/** @internal */
-export const routeNotFound = make<Error.RouteNotFound>("RouteNotFound")
-
-/** @internal */
-export const serveError = make<Error.ServeError>("ServeError")
-
 /** @internal */
 export const clientAbortFiberId = globalValue(
   "@effect/platform/Http/ServerError/clientAbortFiberId",

package/src/internal/http/serverRequest.ts

@@ -1,5 +1,6 @@
 import type * as ParseResult from "@effect/schema/ParseResult"
 import type * as Schema from "@effect/schema/Schema"
+import * as Channel from "effect/Channel"
 import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
 import * as Option from "effect/Option"
@@ -14,6 +15,7 @@ import * as Error from "../../Http/ServerError.js"
 import type * as ServerRequest from "../../Http/ServerRequest.js"
 import * as UrlParams from "../../Http/UrlParams.js"
 import type * as Path from "../../Path.js"
+import * as Socket from "../../Socket.js"
 
 /** @internal */
 export const TypeId: ServerRequest.TypeId = Symbol.for("@effect/platform/Http/ServerRequest") as ServerRequest.TypeId
@@ -21,6 +23,12 @@ export const TypeId: ServerRequest.TypeId = Symbol.for("@effect/platform/Http/Se
 /** @internal */
 export const serverRequestTag = Context.GenericTag<ServerRequest.ServerRequest>("@effect/platform/Http/ServerRequest")
 
+/** @internal */
+export const upgrade = Effect.flatMap(serverRequestTag, (request) => request.upgrade)
+
+/** @internal */
+export const upgradeChannel = <IE = never>() => Channel.unwrap(Effect.map(upgrade, Socket.toChannelWith<IE>()))
+
 /** @internal */
 export const multipartPersisted = Effect.flatMap(serverRequestTag, (request) => request.multipart)
 
@@ -90,7 +98,7 @@ export const schemaBodyFormJson = <A, I, R>(schema: Schema.Schema<A, I, R>) => {
         if (isMultipart(request)) {
           return Effect.flatMap(
             Effect.mapError(request.multipart, (error) =>
-              Error.RequestError({
+              new Error.RequestError({
                 request,
                 reason: "Decode",
                 error
@@ -150,16 +158,18 @@ class ServerRequestImpl implements ServerRequest.ServerRequest {
   get stream(): Stream.Stream<Uint8Array, Error.RequestError> {
     return this.source.body
       ? Stream.fromReadableStream(() => this.source.body as any, (_) =>
-        Error.RequestError({
+        new Error.RequestError({
           request: this,
           reason: "Decode",
           error: _
         }))
-      : Stream.fail(Error.RequestError({
-        request: this,
-        reason: "Decode",
-        error: "can not create stream from empty body"
-      }))
+      : Stream.fail(
+        new Error.RequestError({
+          request: this,
+          reason: "Decode",
+          error: "can not create stream from empty body"
+        })
+      )
   }
 
   private textEffect: Effect.Effect<string, Error.RequestError> | undefined
@@ -171,7 +181,7 @@ class ServerRequestImpl implements ServerRequest.ServerRequest {
       Effect.tryPromise({
         try: () => this.source.text(),
         catch: (error) =>
-          Error.RequestError({
+          new Error.RequestError({
             request: this,
             reason: "Decode",
             error
@@ -185,7 +195,7 @@ class ServerRequestImpl implements ServerRequest.ServerRequest {
     return Effect.tryMap(this.text, {
       try: (_) => JSON.parse(_) as unknown,
       catch: (error) =>
-        Error.RequestError({
+        new Error.RequestError({
           request: this,
           reason: "Decode",
           error
@@ -198,7 +208,7 @@ class ServerRequestImpl implements ServerRequest.ServerRequest {
       Effect.try({
         try: () => UrlParams.fromInput(new URLSearchParams(_)),
         catch: (error) =>
-          Error.RequestError({
+          new Error.RequestError({
             request: this,
             reason: "Decode",
             error
@@ -243,7 +253,7 @@ class ServerRequestImpl implements ServerRequest.ServerRequest {
       Effect.tryPromise({
         try: () => this.source.arrayBuffer(),
         catch: (error) =>
-          Error.RequestError({
+          new Error.RequestError({
             request: this,
             reason: "Decode",
             error
@@ -252,4 +262,14 @@ class ServerRequestImpl implements ServerRequest.ServerRequest {
     ))
     return this.arrayBufferEffect
   }
+
+  get upgrade(): Effect.Effect<Socket.Socket, Error.RequestError> {
+    return Effect.fail(
+      new Error.RequestError({
+        request: this,
+        reason: "Decode",
+        error: "Not an upgradeable ServerRequest"
+      })
+    )
+  }
 }