@effect/platform 0.47.0 → 0.48.0

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

@@ -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)
@@ -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"
+      })
+    )
   }
 }