@effect/platform 0.47.0 → 0.47.1

package/src/Http/Body.ts

@@ -4,6 +4,7 @@
 import type * as ParseResult from "@effect/schema/ParseResult"
 import type * as Schema from "@effect/schema/Schema"
 import type * as Effect from "effect/Effect"
+import * as Predicate from "effect/Predicate"
 import type * as Stream_ from "effect/Stream"
 import type * as PlatformError from "../Error.js"
 import type * as FileSystem from "../FileSystem.js"
@@ -22,6 +23,12 @@ export const TypeId: unique symbol = internal.TypeId
  */
 export type TypeId = typeof TypeId
 
+/**
+ * @since 1.0.0
+ * @category refinements
+ */
+export const isBody = (u: unknown): u is Body => Predicate.hasProperty(u, TypeId)
+
 /**
  * @since 1.0.0
  * @category models
@@ -122,7 +129,13 @@ export interface Raw extends Body.Proto {
  * @since 1.0.0
  * @category constructors
  */
-export const raw: (body: unknown) => Raw = internal.raw
+export const raw: (
+  body: unknown,
+  options?: {
+    readonly contentType?: string | undefined
+    readonly contentLength?: number | undefined
+  } | undefined
+) => Raw = internal.raw
 
 /**
  * @since 1.0.0

package/src/Http/ClientError.ts

@@ -1,6 +1,7 @@
 /**
  * @since 1.0.0
  */
+import * as Error from "@effect/platform/Error"
 import * as internal from "../internal/http/clientError.js"
 import type * as ClientRequest from "./ClientRequest.js"
 import type * as ClientResponse from "./ClientResponse.js"
@@ -23,57 +24,39 @@ export type TypeId = typeof TypeId
  */
 export type HttpClientError = RequestError | ResponseError
 
-/**
- * @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 Error.RefailError(TypeId, "RequestError")<{
   readonly request: ClientRequest.ClientRequest
   readonly reason: "Transport" | "Encode" | "InvalidUrl"
-  readonly error: unknown
-}
+}> {
+  get methodAndUrl() {
+    return `${this.request.method} ${this.request.url}`
+  }
 
-/**
- * @since 1.0.0
- * @category error
- */
-export const RequestError: (props: Omit<RequestError, HttpError.ProvidedFields>) => RequestError = internal.requestError
+  get message() {
+    const errorString = super.message
+    return `${this.reason} error (${this.methodAndUrl}): ${errorString}`
+  }
+}
 
 /**
  * @since 1.0.0
  * @category error
  */
-export interface ResponseError extends HttpError.Proto {
-  readonly _tag: "ResponseError"
+export class ResponseError extends Error.RefailError(TypeId, "ResponseError")<{
   readonly request: ClientRequest.ClientRequest
   readonly response: ClientResponse.ClientResponse
   readonly reason: "StatusCode" | "Decode" | "EmptyBody"
-  readonly error: unknown
-}
+}> {
+  get methodAndUrl() {
+    return `${this.request.method} ${this.request.url}`
+  }
 
-/**
- * @since 1.0.0
- * @category error
- */
-export const ResponseError: (props: Omit<ResponseError, HttpError.ProvidedFields>) => ResponseError =
-  internal.responseError
+  get message() {
+    const errorString = super.message
+    return `${this.reason} error (${this.response.status} ${this.methodAndUrl}): ${errorString}`
+  }
+}

package/src/Http/Headers.ts

@@ -1,12 +1,14 @@
 /**
  * @since 1.0.0
  */
-import { dual } from "effect/Function"
+import * as Schema from "@effect/schema/Schema"
+import { dual, identity } from "effect/Function"
 import type * as Option from "effect/Option"
 import * as Predicate from "effect/Predicate"
 import * as ReadonlyArray from "effect/ReadonlyArray"
 import * as ReadonlyRecord from "effect/ReadonlyRecord"
 import * as Secret from "effect/Secret"
+import * as String from "effect/String"
 
 /**
  * @since 1.0.0
@@ -20,6 +22,12 @@ export const HeadersTypeId = Symbol.for("@effect/platform/Http/Headers")
  */
 export type HeadersTypeId = typeof HeadersTypeId
 
+/**
+ * @since 1.0.0
+ * @category refinements
+ */
+export const isHeaders = (u: unknown): u is Headers => Predicate.hasProperty(u, HeadersTypeId)
+
 /**
  * @since 1.0.0
  * @category models
@@ -29,6 +37,26 @@ export interface Headers {
   readonly [key: string]: string
 }
 
+/**
+ * @since 1.0.0
+ * @category schemas
+ */
+export const schemaFromSelf: Schema.Schema<Headers> = Schema.declare(isHeaders, {
+  identifier: "Headers",
+  equivalence: () => ReadonlyRecord.getEquivalence(String.Equivalence)
+})
+
+/**
+ * @since 1.0.0
+ * @category schemas
+ */
+export const schema: Schema.Schema<Headers, ReadonlyRecord.ReadonlyRecord<string, string>> = Schema.transform(
+  Schema.record(Schema.string, Schema.string),
+  schemaFromSelf,
+  (record) => fromInput(record),
+  identity
+)
+
 /**
  * @since 1.0.0
  * @category models

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/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/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

@@ -98,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
@@ -158,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
@@ -179,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
@@ -193,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
@@ -206,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
@@ -251,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
@@ -262,10 +264,12 @@ class ServerRequestImpl implements ServerRequest.ServerRequest {
   }
 
   get upgrade(): Effect.Effect<Socket.Socket, Error.RequestError> {
-    return Effect.fail(Error.RequestError({
-      request: this,
-      reason: "Decode",
-      error: "Not an upgradeable ServerRequest"
-    }))
+    return Effect.fail(
+      new Error.RequestError({
+        request: this,
+        reason: "Decode",
+        error: "Not an upgradeable ServerRequest"
+      })
+    )
   }
 }