@effect/platform 0.57.8 → 0.58.1

package/src/{Http/ServerResponse.ts → HttpServerResponse.ts}

@@ -6,21 +6,21 @@ import type * as Schema from "@effect/schema/Schema"
 import type * as Effect from "effect/Effect"
 import type { Inspectable } from "effect/Inspectable"
 import type * as Stream from "effect/Stream"
-import type * as PlatformError from "../Error.js"
-import type * as FileSystem from "../FileSystem.js"
-import * as internal from "../internal/http/serverResponse.js"
-import type * as Template from "../Template.js"
-import type * as Body from "./Body.js"
 import type { Cookie, Cookies, CookiesError } from "./Cookies.js"
+import type * as PlatformError from "./Error.js"
+import type * as FileSystem from "./FileSystem.js"
 import type * as Headers from "./Headers.js"
-import type * as Platform from "./Platform.js"
+import type * as Body from "./HttpBody.js"
+import type * as Platform from "./HttpPlatform.js"
+import * as internal from "./internal/httpServerResponse.js"
+import type * as Template from "./Template.js"
 import type * as UrlParams from "./UrlParams.js"
 
 /**
  * @since 1.0.0
  * @category type ids
  */
-export const TypeId: unique symbol = Symbol.for("@effect/platform/Http/ServerResponse")
+export const TypeId: unique symbol = Symbol.for("@effect/platform/HttpServerResponse")
 
 /**
  * @since 1.0.0
@@ -32,13 +32,13 @@ export type TypeId = typeof TypeId
  * @since 1.0.0
  * @category models
  */
-export interface ServerResponse extends Effect.Effect<ServerResponse>, Inspectable {
+export interface HttpServerResponse extends Effect.Effect<HttpServerResponse>, Inspectable {
   readonly [TypeId]: TypeId
   readonly status: number
   readonly statusText?: string | undefined
   readonly headers: Headers.Headers
   readonly cookies: Cookies
-  readonly body: Body.Body
+  readonly body: Body.HttpBody
 }
 
 /**
@@ -74,26 +74,26 @@ export declare namespace Options {
 /**
  * @since 1.0.0
  */
-export const isServerResponse: (u: unknown) => u is ServerResponse = internal.isServerResponse
+export const isServerResponse: (u: unknown) => u is HttpServerResponse = internal.isServerResponse
 
 /**
  * @since 1.0.0
  * @category constructors
  */
-export const empty: (options?: Options.WithContent | undefined) => ServerResponse = internal.empty
+export const empty: (options?: Options.WithContent | undefined) => HttpServerResponse = internal.empty
 
 /**
  * @since 1.0.0
  * @category constructors
  */
-export const uint8Array: (body: Uint8Array, options?: Options.WithContentType | undefined) => ServerResponse =
+export const uint8Array: (body: Uint8Array, options?: Options.WithContentType | undefined) => HttpServerResponse =
   internal.uint8Array
 
 /**
  * @since 1.0.0
  * @category constructors
  */
-export const text: (body: string, options?: Options.WithContentType | undefined) => ServerResponse = internal.text
+export const text: (body: string, options?: Options.WithContentType | undefined) => HttpServerResponse = internal.text
 
 /**
  * @since 1.0.0
@@ -103,8 +103,8 @@ export const html: {
   <A extends ReadonlyArray<Template.Interpolated>>(
     strings: TemplateStringsArray,
     ...args: A
-  ): Effect.Effect<ServerResponse, Template.Interpolated.Error<A[number]>, Template.Interpolated.Context<A[number]>>
-  (html: string): ServerResponse
+  ): Effect.Effect<HttpServerResponse, Template.Interpolated.Error<A[number]>, Template.Interpolated.Context<A[number]>>
+  (html: string): HttpServerResponse
 } = internal.html
 
 /**
@@ -114,7 +114,7 @@ export const html: {
 export const htmlStream: <A extends ReadonlyArray<Template.InterpolatedWithStream>>(
   strings: TemplateStringsArray,
   ...args: A
-) => Effect.Effect<ServerResponse, never, Template.Interpolated.Context<A[number]>> = internal.htmlStream
+) => Effect.Effect<HttpServerResponse, never, Template.Interpolated.Context<A[number]>> = internal.htmlStream
 
 /**
  * @since 1.0.0
@@ -123,7 +123,7 @@ export const htmlStream: <A extends ReadonlyArray<Template.InterpolatedWithStrea
 export const json: (
   body: unknown,
   options?: Options.WithContent | undefined
-) => Effect.Effect<ServerResponse, Body.BodyError> = internal.json
+) => Effect.Effect<HttpServerResponse, Body.HttpBodyError> = internal.json
 
 /**
  * @since 1.0.0
@@ -132,41 +132,44 @@ export const json: (
 export const schemaJson: <A, I, R>(
   schema: Schema.Schema<A, I, R>,
   options?: ParseOptions | undefined
-) => (body: A, options?: Options.WithContent | undefined) => Effect.Effect<ServerResponse, Body.BodyError, R> =
+) => (body: A, options?: Options.WithContent | undefined) => Effect.Effect<HttpServerResponse, Body.HttpBodyError, R> =
   internal.schemaJson
 
 /**
  * @since 1.0.0
  * @category constructors
  */
-export const unsafeJson: (body: unknown, options?: Options.WithContent | undefined) => ServerResponse =
+export const unsafeJson: (body: unknown, options?: Options.WithContent | undefined) => HttpServerResponse =
   internal.unsafeJson
 
 /**
  * @since 1.0.0
  * @category constructors
  */
-export const urlParams: (body: UrlParams.Input, options?: Options.WithContent | undefined) => ServerResponse =
+export const urlParams: (body: UrlParams.Input, options?: Options.WithContent | undefined) => HttpServerResponse =
   internal.urlParams
 
 /**
  * @since 1.0.0
  * @category constructors
  */
-export const raw: (body: unknown, options?: Options | undefined) => ServerResponse = internal.raw
+export const raw: (body: unknown, options?: Options | undefined) => HttpServerResponse = internal.raw
 
 /**
  * @since 1.0.0
  * @category constructors
  */
-export const formData: (body: FormData, options?: Options.WithContent | undefined) => ServerResponse = internal.formData
+export const formData: (body: FormData, options?: Options.WithContent | undefined) => HttpServerResponse =
+  internal.formData
 
 /**
  * @since 1.0.0
  * @category constructors
  */
-export const stream: <E>(body: Stream.Stream<Uint8Array, E, never>, options?: Options | undefined) => ServerResponse =
-  internal.stream
+export const stream: <E>(
+  body: Stream.Stream<Uint8Array, E, never>,
+  options?: Options | undefined
+) => HttpServerResponse = internal.stream
 
 /**
  * @since 1.0.0
@@ -175,24 +178,24 @@ export const stream: <E>(body: Stream.Stream<Uint8Array, E, never>, options?: Op
 export const file: (
   path: string,
   options?: (Options & FileSystem.StreamOptions) | undefined
-) => Effect.Effect<ServerResponse, PlatformError.PlatformError, Platform.Platform> = internal.file
+) => Effect.Effect<HttpServerResponse, PlatformError.PlatformError, Platform.HttpPlatform> = internal.file
 
 /**
  * @since 1.0.0
  * @category constructors
  */
 export const fileWeb: (
-  file: Body.Body.FileLike,
+  file: Body.HttpBody.FileLike,
   options?: (Options.WithContent & FileSystem.StreamOptions) | undefined
-) => Effect.Effect<ServerResponse, never, Platform.Platform> = internal.fileWeb
+) => Effect.Effect<HttpServerResponse, never, Platform.HttpPlatform> = internal.fileWeb
 
 /**
  * @since 1.0.0
  * @category combinators
  */
 export const setHeader: {
-  (key: string, value: string): (self: ServerResponse) => ServerResponse
-  (self: ServerResponse, key: string, value: string): ServerResponse
+  (key: string, value: string): (self: HttpServerResponse) => HttpServerResponse
+  (self: HttpServerResponse, key: string, value: string): HttpServerResponse
 } = internal.setHeader
 
 /**
@@ -200,8 +203,8 @@ export const setHeader: {
  * @category combinators
  */
 export const setHeaders: {
-  (input: Headers.Input): (self: ServerResponse) => ServerResponse
-  (self: ServerResponse, input: Headers.Input): ServerResponse
+  (input: Headers.Input): (self: HttpServerResponse) => HttpServerResponse
+  (self: HttpServerResponse, input: Headers.Input): HttpServerResponse
 } = internal.setHeaders
 
 /**
@@ -209,8 +212,8 @@ export const setHeaders: {
  * @category combinators
  */
 export const removeCookie: {
-  (name: string): (self: ServerResponse) => ServerResponse
-  (self: ServerResponse, name: string): ServerResponse
+  (name: string): (self: HttpServerResponse) => HttpServerResponse
+  (self: HttpServerResponse, name: string): HttpServerResponse
 } = internal.removeCookie
 
 /**
@@ -218,8 +221,8 @@ export const removeCookie: {
  * @category combinators
  */
 export const replaceCookies: {
-  (cookies: Cookies): (self: ServerResponse) => ServerResponse
-  (self: ServerResponse, cookies: Cookies): ServerResponse
+  (cookies: Cookies): (self: HttpServerResponse) => HttpServerResponse
+  (self: HttpServerResponse, cookies: Cookies): HttpServerResponse
 } = internal.replaceCookies
 
 /**
@@ -232,18 +235,18 @@ export const setCookie: {
     value: string,
     options?: Cookie["options"]
   ): (
-    self: ServerResponse
+    self: HttpServerResponse
   ) => Effect.Effect<
-    ServerResponse,
+    HttpServerResponse,
     CookiesError
   >
   (
-    self: ServerResponse,
+    self: HttpServerResponse,
     name: string,
     value: string,
     options?: Cookie["options"]
   ): Effect.Effect<
-    ServerResponse,
+    HttpServerResponse,
     CookiesError
   >
 } = internal.setCookie
@@ -257,13 +260,13 @@ export const unsafeSetCookie: {
     name: string,
     value: string,
     options?: Cookie["options"]
-  ): (self: ServerResponse) => ServerResponse
+  ): (self: HttpServerResponse) => HttpServerResponse
   (
-    self: ServerResponse,
+    self: HttpServerResponse,
     name: string,
     value: string,
     options?: Cookie["options"]
-  ): ServerResponse
+  ): HttpServerResponse
 } = internal.unsafeSetCookie
 
 /**
@@ -271,8 +274,8 @@ export const unsafeSetCookie: {
  * @category combinators
  */
 export const updateCookies: {
-  (f: (cookies: Cookies) => Cookies): (self: ServerResponse) => ServerResponse
-  (self: ServerResponse, f: (cookies: Cookies) => Cookies): ServerResponse
+  (f: (cookies: Cookies) => Cookies): (self: HttpServerResponse) => HttpServerResponse
+  (self: HttpServerResponse, f: (cookies: Cookies) => Cookies): HttpServerResponse
 } = internal.updateCookies
 
 /**
@@ -288,9 +291,9 @@ export const setCookies: {
         options?: Cookie["options"]
       ]
     >
-  ): (self: ServerResponse) => Effect.Effect<ServerResponse, CookiesError, never>
+  ): (self: HttpServerResponse) => Effect.Effect<HttpServerResponse, CookiesError, never>
   (
-    self: ServerResponse,
+    self: HttpServerResponse,
     cookies: Iterable<
       readonly [
         name: string,
@@ -298,7 +301,7 @@ export const setCookies: {
         options?: Cookie["options"]
       ]
     >
-  ): Effect.Effect<ServerResponse, CookiesError, never>
+  ): Effect.Effect<HttpServerResponse, CookiesError, never>
 } = internal.setCookies
 
 /**
@@ -314,9 +317,9 @@ export const unsafeSetCookies: {
         options?: Cookie["options"]
       ]
     >
-  ): (self: ServerResponse) => ServerResponse
+  ): (self: HttpServerResponse) => HttpServerResponse
   (
-    self: ServerResponse,
+    self: HttpServerResponse,
     cookies: Iterable<
       readonly [
         name: string,
@@ -324,7 +327,7 @@ export const unsafeSetCookies: {
         options?: Cookie["options"]
       ]
     >
-  ): ServerResponse
+  ): HttpServerResponse
 } = internal.unsafeSetCookies
 
 /**
@@ -332,8 +335,8 @@ export const unsafeSetCookies: {
  * @category combinators
  */
 export const setBody: {
-  (body: Body.Body): (self: ServerResponse) => ServerResponse
-  (self: ServerResponse, body: Body.Body): ServerResponse
+  (body: Body.HttpBody): (self: HttpServerResponse) => HttpServerResponse
+  (self: HttpServerResponse, body: Body.HttpBody): HttpServerResponse
 } = internal.setBody
 
 /**
@@ -341,12 +344,12 @@ export const setBody: {
  * @category combinators
  */
 export const setStatus: {
-  (status: number, statusText?: string | undefined): (self: ServerResponse) => ServerResponse
-  (self: ServerResponse, status: number, statusText?: string | undefined): ServerResponse
+  (status: number, statusText?: string | undefined): (self: HttpServerResponse) => HttpServerResponse
+  (self: HttpServerResponse, status: number, statusText?: string | undefined): HttpServerResponse
 } = internal.setStatus
 
 /**
  * @since 1.0.0
  * @category conversions
  */
-export const toWeb: (response: ServerResponse, withoutBody?: boolean | undefined) => Response = internal.toWeb
+export const toWeb: (response: HttpServerResponse, withoutBody?: boolean | undefined) => Response = internal.toWeb

package/src/{Http/Multipart.ts → Multipart.ts}

@@ -14,9 +14,9 @@ import type * as Option from "effect/Option"
 import type * as Scope from "effect/Scope"
 import type * as Stream from "effect/Stream"
 import type * as Multipasta from "multipasta"
-import type * as FileSystem from "../FileSystem.js"
-import * as internal from "../internal/http/multipart.js"
-import type * as Path from "../Path.js"
+import type * as FileSystem from "./FileSystem.js"
+import * as internal from "./internal/multipart.js"
+import type * as Path from "./Path.js"
 
 /**
  * @since 1.0.0

package/src/Socket.ts

@@ -298,6 +298,15 @@ export interface WebSocketConstructor {
 export const WebSocketConstructor: Context.Tag<WebSocketConstructor, (url: string) => globalThis.WebSocket> = Context
   .GenericTag("@effect/platform/Socket/WebSocketConstructor")
 
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+export const layerWebSocketConstructorGlobal: Layer.Layer<WebSocketConstructor> = Layer.succeed(
+  WebSocketConstructor,
+  (url: string) => new globalThis.WebSocket(url)
+)
+
 /**
  * @since 1.0.0
  * @category constructors
@@ -502,3 +511,134 @@ export const currentSendQueueCapacity: FiberRef.FiberRef<number> = globalValue(
   "@effect/platform/Socket/currentSendQueueCapacity",
   () => FiberRef.unsafeMake(16)
 )
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface InputTransformStream {
+  readonly readable: ReadableStream<Uint8Array> | ReadableStream<string> | ReadableStream<Uint8Array | string>
+  readonly writable: WritableStream<Uint8Array>
+}
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const fromTransformStream = <R>(acquire: Effect.Effect<InputTransformStream, SocketError, R>, options?: {
+  readonly closeCodeIsError?: (code: number) => boolean
+}): Effect.Effect<Socket, never, Exclude<R, Scope.Scope>> => {
+  const EOF = Symbol()
+  return Effect.withFiberRuntime<Socket, never, Exclude<R, Scope.Scope>>((fiber) =>
+    Effect.map(
+      Queue.dropping<Uint8Array | string | CloseEvent | typeof EOF>(fiber.getFiberRef(currentSendQueueCapacity)),
+      (sendQueue) => {
+        const acquireContext = fiber.getFiberRef(FiberRef.currentContext) as Context.Context<Exclude<R, Scope.Scope>>
+        const closeCodeIsError = options?.closeCodeIsError ?? defaultCloseCodeIsError
+        const runRaw = <_, E, R>(handler: (_: string | Uint8Array) => Effect.Effect<_, E, R>) =>
+          Effect.scope.pipe(
+            Effect.bindTo("scope"),
+            Effect.bind("stream", ({ scope }) =>
+              acquire.pipe(
+                Effect.provide(Context.add(acquireContext, Scope.Scope, scope))
+              ) as Effect.Effect<InputTransformStream>),
+            Effect.bind("reader", ({ stream }) =>
+              Effect.acquireRelease(
+                Effect.sync(() => stream.readable.getReader()),
+                (reader) =>
+                  Effect.promise(() => reader.cancel()).pipe(
+                    Effect.tap(() => {
+                      reader.releaseLock()
+                    })
+                  )
+              )),
+            Effect.bind("writer", ({ stream }) =>
+              Effect.acquireRelease(
+                Effect.sync(() => stream.writable.getWriter()),
+                (reader) => Effect.sync(() => reader.releaseLock())
+              )),
+            Effect.bind("fiberSet", () => FiberSet.make<any, E | SocketError>()),
+            Effect.tap(({ fiberSet, writer }) => {
+              const encoder = new TextEncoder()
+              return Queue.take(sendQueue).pipe(
+                Effect.tap((chunk) => {
+                  if (
+                    chunk === EOF ||
+                    isCloseEvent(chunk)
+                  ) {
+                    return Effect.zipRight(
+                      Effect.promise(() => writer.close()),
+                      chunk === EOF ? Effect.interrupt : Effect.fail(
+                        new SocketCloseError({
+                          reason: "Close",
+                          code: chunk.code,
+                          closeReason: chunk.reason
+                        })
+                      )
+                    )
+                  }
+                  return Effect.try({
+                    try: () => {
+                      if (typeof chunk === "string") {
+                        writer.write(encoder.encode(chunk))
+                      } else {
+                        writer.write(chunk)
+                      }
+                    },
+                    catch: (error) => new SocketGenericError({ reason: "Write", error })
+                  })
+                }),
+                Effect.forever,
+                FiberSet.run(fiberSet)
+              )
+            }),
+            Effect.tap(({ fiberSet, reader }) =>
+              Effect.tryPromise({
+                try: () => reader.read(),
+                catch: (error) => new SocketGenericError({ reason: "Read", error })
+              }).pipe(
+                Effect.tap((result) => {
+                  if (result.done) {
+                    return Effect.fail(new SocketCloseError({ reason: "Close", code: 1000 }))
+                  }
+                  return handler(result.value)
+                }),
+                Effect.forever,
+                FiberSet.run(fiberSet)
+              )
+            ),
+            Effect.tap(({ fiberSet }) =>
+              Effect.catchIf(
+                FiberSet.join(fiberSet),
+                SocketCloseError.isClean((_) => !closeCodeIsError(_)),
+                (_) => Effect.void
+              )
+            ),
+            Effect.scoped,
+            Effect.interruptible
+          )
+
+        const encoder = new TextEncoder()
+        const run = <_, E, R>(handler: (_: Uint8Array) => Effect.Effect<_, E, R>) =>
+          runRaw((data) =>
+            typeof data === "string"
+              ? handler(encoder.encode(data))
+              : handler(data)
+          )
+
+        const write = (chunk: Uint8Array | string | CloseEvent) => Queue.offer(sendQueue, chunk)
+        const writer = Effect.acquireRelease(
+          Effect.succeed(write),
+          () => Queue.offer(sendQueue, EOF)
+        )
+
+        return Socket.of({
+          [TypeId]: TypeId,
+          run,
+          runRaw,
+          writer
+        })
+      }
+    )
+  )
+}

package/src/index.ts

@@ -8,6 +8,11 @@ export * as Command from "./Command.js"
  */
 export * as CommandExecutor from "./CommandExecutor.js"
 
+/**
+ * @since 1.0.0
+ */
+export * as Cookies from "./Cookies.js"
+
 /**
  * @since 1.0.0
  */
@@ -18,26 +23,117 @@ export * as Effectify from "./Effectify.js"
  */
 export * as Error from "./Error.js"
 
+/**
+ * @since 1.0.0
+ */
+export * as Etag from "./Etag.js"
+
 /**
  * @since 1.0.0
  */
 export * as FileSystem from "./FileSystem.js"
 
+/**
+ * @since 1.0.0
+ */
+export * as Headers from "./Headers.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as HttpApp from "./HttpApp.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as HttpBody from "./HttpBody.js"
+
 /**
  * @since 1.0.0
  */
 export * as HttpClient from "./HttpClient.js"
 
+/**
+ * @since 1.0.0
+ */
+export * as HttpClientError from "./HttpClientError.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as HttpClientRequest from "./HttpClientRequest.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as HttpClientResponse from "./HttpClientResponse.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as HttpIncomingMessage from "./HttpIncomingMessage.js"
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export * as HttpMethod from "./HttpMethod.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as HttpMiddleware from "./HttpMiddleware.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as HttpMultiplex from "./HttpMultiplex.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as HttpPlatform from "./HttpPlatform.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as HttpRouter from "./HttpRouter.js"
+
 /**
  * @since 1.0.0
  */
 export * as HttpServer from "./HttpServer.js"
 
+/**
+ * @since 1.0.0
+ */
+export * as HttpServerError from "./HttpServerError.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as HttpServerRequest from "./HttpServerRequest.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as HttpServerResponse from "./HttpServerResponse.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as HttpTraceContext from "./HttpTraceContext.js"
+
 /**
  * @since 1.0.0
  */
 export * as KeyValueStore from "./KeyValueStore.js"
 
+/**
+ * @since 1.0.0
+ */
+export * as Multipart from "./Multipart.js"
+
 /**
  * @since 1.0.0
  */
@@ -78,6 +174,11 @@ export * as Terminal from "./Terminal.js"
  */
 export * as Transferable from "./Transferable.js"
 
+/**
+ * @since 1.0.0
+ */
+export * as UrlParams from "./UrlParams.js"
+
 /**
  * @since 1.0.0
  */

package/src/internal/{http/etag.ts → etag.ts}

@@ -1,13 +1,13 @@
 import * as Context from "effect/Context"
-import type * as Etag from "../../Http/Etag.js"
+import type * as Etag from "../Etag.js"
 
 /** @internal */
 export const GeneratorTypeId: Etag.GeneratorTypeId = Symbol.for(
-  "@effect/platform/Http/Etag/Generator"
+  "@effect/platform/Etag/Generator"
 ) as Etag.GeneratorTypeId
 
 /** @internal */
-export const tag = Context.GenericTag<Etag.Generator>("@effect/platform/Http/Etag/Generator")
+export const tag = Context.GenericTag<Etag.Generator>("@effect/platform/Etag/Generator")
 
 /** @internal */
 export const toString = (self: Etag.Etag): string => {