effect 4.0.0-beta.92 → 4.0.0-beta.94

package/src/unstable/httpapi/HttpApiBuilder.ts

@@ -21,6 +21,7 @@ import * as Layer from "../../Layer.ts"
 import * as Option from "../../Option.ts"
 import type { Path } from "../../Path.ts"
 import { type Pipeable, pipeArguments } from "../../Pipeable.ts"
+import { hasProperty } from "../../Predicate.ts"
 import * as Redacted from "../../Redacted.ts"
 import * as Result from "../../Result.ts"
 import * as Schema from "../../Schema.ts"
@@ -603,13 +604,20 @@ function decodePayload(
       )
     }
     case "Json":
-      const json = Effect.orDie(Effect.flatMap(httpRequest.text, (text) => {
+      return Effect.flatMap(Effect.orDie(httpRequest.text), (text) => {
         if (text === "") {
-          return existing.nullOnEmpty ? Effect.succeed(null) : Effect.undefined
+          return decode(existing.nullOnEmpty ? null : undefined)
         }
-        return Effect.succeed(JSON.parse(text))
-      }))
-      return Effect.flatMap(json, decode)
+        try {
+          return decode(JSON.parse(text))
+        } catch (cause) {
+          return Effect.fail(
+            new Schema.SchemaError(
+              new SchemaIssue.InvalidValue(Option.some(text), { message: `Invalid JSON: ${cause}` })
+            )
+          )
+        }
+      })
     case "Text":
       return Effect.flatMap(Effect.orDie(httpRequest.text), decode)
     case "FormUrlEncoded": {
@@ -766,6 +774,7 @@ const makeSecurityMiddleware = (
     readonly group: HttpApiGroup.AnyWithProps
     readonly endpoint: HttpApiEndpoint.AnyWithProps
   }) {
+    handler = Effect.mapError(handler, (error) => new HandlerError(error))
     let lastResult: Result.Result<any, any> | undefined
     for (let i = 0; i < entries.length; i++) {
       const { decode, middleware } = entries[i]
@@ -776,6 +785,9 @@ const makeSecurityMiddleware = (
           group: options.group
         })))
       if (Result.isFailure(result)) {
+        if (isHandlerError(result.failure)) {
+          return yield* Effect.fail(result.failure.error)
+        }
         lastResult = result
         continue
       }
@@ -788,6 +800,16 @@ const makeSecurityMiddleware = (
   return middleware
 }
 
+const HandlerErrorTypeId = "~effect/httpapi/HttpApiBuilder/HandlerError" as const
+class HandlerError {
+  readonly [HandlerErrorTypeId] = HandlerErrorTypeId
+  readonly error: unknown
+  constructor(error: unknown) {
+    this.error = error
+  }
+}
+const isHandlerError = (value: unknown): value is HandlerError => hasProperty(value, HandlerErrorTypeId)
+
 const $HttpServerResponse = Schema.declare(Response.isHttpServerResponse)
 
 type StreamEncoder = (response: unknown, context: Context.Context<never>) =>
@@ -807,7 +829,9 @@ function makeStreamEncoder(endpoint: HttpApiEndpoint.AnyWithProps): StreamEncode
   if (HttpApiSchema.isStreamUint8Array(streamSchema)) {
     return (response, context) => {
       if (!Stream.isStream(response)) {
-        return hasBuffered ? undefined : expectedStreamResponse(response)
+        return hasBuffered ? undefined : new Schema.SchemaError(
+          new SchemaIssue.InvalidValue(Option.some(response), { message: "Expected a streaming response" })
+        )
       }
 
       return Effect.succeed(Response.stream(
@@ -824,7 +848,9 @@ function makeStreamEncoder(endpoint: HttpApiEndpoint.AnyWithProps): StreamEncode
 
   return (response, context) => {
     if (!Stream.isStream(response)) {
-      return hasBuffered ? undefined : expectedStreamResponse(response)
+      return hasBuffered ? undefined : new Schema.SchemaError(
+        new SchemaIssue.InvalidValue(Option.some(response), { message: "Expected a streaming response" })
+      )
     }
 
     return Effect.succeed(Response.stream(
@@ -852,16 +878,6 @@ function hasBufferedSuccess(endpoint: HttpApiEndpoint.AnyWithProps): boolean {
   return endpoint.success.size === 0
 }
 
-function expectedStreamResponse(response: unknown) {
-  return Effect.fail(
-    makeSchemaError(
-      new SchemaIssue.InvalidValue(Option.some(response), {
-        message: "Expected a streaming response"
-      })
-    )
-  )
-}
-
 interface SseStreamEncoder {
   readonly sseMode: HttpApiSchema.StreamSseMode
   readonly encodeEvents: (
@@ -922,10 +938,6 @@ function renderSseEvent(event: Sse.EventEncoded) {
   })
 }
 
-function makeSchemaError(issue: SchemaIssue.Issue): Schema.SchemaError {
-  return new Schema.SchemaError(issue)
-}
-
 const toResponseSuccessSchema = toResponseSchema(HttpApiSchema.getStatusSuccess)
 const toResponseErrorSchema = toResponseSchema(HttpApiSchema.getStatusError)
 

package/src/unstable/httpapi/HttpApiClient.ts

@@ -636,10 +636,10 @@ export const urlBuilder = <Api extends HttpApi.Any>(api: Api, options?: {
       const makeUrl = compilePath(endpoint.path)
       const encodeParams = endpoint.params === undefined
         ? undefined
-        : Schema.encodeSync(endpoint.params as Schema.Codec<unknown, unknown>)
+        : Schema.encodeSync(endpoint.params as unknown as Schema.ConstraintEncoder<unknown>)
       const encodeQuery = endpoint.query === undefined
         ? undefined
-        : Schema.encodeSync(endpoint.query as Schema.Codec<unknown, unknown>)
+        : Schema.encodeSync(endpoint.query as unknown as Schema.ConstraintEncoder<unknown>)
 
       const endpointBuilder = (request?: {
         readonly params?: unknown

package/src/unstable/httpapi/HttpApiEndpoint.ts

@@ -1037,8 +1037,8 @@ function makeProto<
  * @since 4.0.0
  */
 export type ParamsConstraint =
-  | Record<string, Schema.Codec<unknown, string | undefined, unknown, unknown>>
-  | Schema.Codec<unknown, Record<string, string | undefined>, unknown, unknown>
+  | Record<string, Schema.Encoder<string | undefined, unknown>>
+  | Schema.Encoder<Record<string, string | undefined>, unknown>
 
 /**
  * Constraint for header schemas: each header must encode to `string | undefined`,
@@ -1048,8 +1048,8 @@ export type ParamsConstraint =
  * @since 4.0.0
  */
 export type HeadersConstraint =
-  | Record<string, Schema.Codec<unknown, string | undefined, unknown, unknown>>
-  | Schema.Codec<unknown, Record<string, string | undefined>, unknown, unknown>
+  | Record<string, Schema.Encoder<string | undefined, unknown>>
+  | Schema.Encoder<Record<string, string | undefined>, unknown>
 
 /**
  * Constraint for query schemas: each field must encode to `string`, an array of
@@ -1059,8 +1059,8 @@ export type HeadersConstraint =
  * @since 4.0.0
  */
 export type QueryConstraint =
-  | Record<string, Schema.Codec<unknown, string | ReadonlyArray<string> | undefined, unknown, unknown>>
-  | Schema.Codec<unknown, string | ReadonlyArray<string> | undefined, unknown, unknown>
+  | Record<string, Schema.Encoder<string | ReadonlyArray<string> | undefined, unknown>>
+  | Schema.Encoder<string | ReadonlyArray<string> | undefined, unknown>
 
 /**
  * Payload schema depends on the HTTP method:
@@ -1075,7 +1075,7 @@ export type QueryConstraint =
  */
 export type PayloadConstraint<Method extends HttpMethod> = Method extends HttpMethod.NoBody ? Record<
     string,
-    Schema.Codec<unknown, string | ReadonlyArray<string> | undefined, unknown, unknown>
+    Schema.Encoder<string | ReadonlyArray<string> | undefined, unknown>
   > :
   Schema.Top | ReadonlyArray<Schema.Top>
 

package/src/unstable/httpapi/HttpApiSchema.ts

@@ -325,7 +325,7 @@ export interface StreamSse<
  * @since 4.0.0
  */
 export interface SseEventFromData<Data extends Schema.Constraint> extends
-  Schema.Codec<
+  Schema.ConstraintCodec<
     {
       readonly id: string | undefined
       readonly event: string

package/src/unstable/observability/OtlpTracer.ts

@@ -17,7 +17,6 @@ import * as Duration from "../../Duration.ts"
 import * as Effect from "../../Effect.ts"
 import type * as Exit from "../../Exit.ts"
 import { flow } from "../../Function.ts"
-import { renderPrettyError } from "../../internal/effect.ts"
 import * as Layer from "../../Layer.ts"
 import * as Option from "../../Option.ts"
 import type * as Scope from "../../Scope.ts"
@@ -285,7 +284,9 @@ const makeOtlpSpan = (self: SpanImpl): OtlpSpan => {
       value: { boolValue: true }
     })
   } else {
-    const errors = Cause.prettyErrors(status.exit.cause)
+    const errors = Cause.prettyErrors(status.exit.cause, {
+      includeCauseInStack: true
+    })
     otelStatus = {
       code: StatusCode.Error
     }
@@ -312,7 +313,7 @@ const makeOtlpSpan = (self: SpanImpl): OtlpSpan => {
             {
               "key": "exception.stacktrace",
               "value": {
-                "stringValue": renderPrettyError(error) ?? "No stack trace available"
+                "stringValue": error.stack ?? "No stack trace available"
               }
             }
           ]

package/src/unstable/reactivity/Atom.ts

@@ -2604,7 +2604,7 @@ export const refreshOnWindowFocus: <A extends Atom<any>>(self: A) => WithoutSeri
  * @category KeyValueStore
  * @since 4.0.0
  */
-export const kvs = <S extends Schema.Codec<any, any>, const Mode extends "sync" | "async" = never>(options: {
+export const kvs = <S extends Schema.ConstraintCodec<any, any>, const Mode extends "sync" | "async" = never>(options: {
   readonly runtime: AtomRuntime<KeyValueStore.KeyValueStore, any>
   readonly key: string
   readonly schema: S
@@ -2669,9 +2669,12 @@ export const kvs = <S extends Schema.Codec<any, any>, const Mode extends "sync"
  * @category search params
  * @since 4.0.0
  */
-export const searchParam = <S extends Schema.Codec<any, string> = never>(name: string, options?: {
-  readonly schema?: S | undefined
-}): Writable<[S] extends [never] ? string : Option.Option<S["Type"]>> => {
+export const searchParam = <S extends Schema.ConstraintCodec<any, string> = never>(
+  name: string,
+  options?: {
+    readonly schema?: S | undefined
+  }
+): Writable<[S] extends [never] ? string : Option.Option<S["Type"]>> => {
   const decode = options?.schema && Schema.decodeExit(options.schema)
   const encode = options?.schema && Schema.encodeExit(options.schema)
   return writable(
@@ -2986,7 +2989,7 @@ export const serializable: {
    * @category combinators
    * @since 4.0.0
    */
-  <R extends Atom<any>, S extends Schema.Codec<Type<R>, any>>(
+  <R extends Atom<any>, S extends Schema.ConstraintCodec<Type<R>, any>>(
     options: {
       readonly key: string
       readonly schema: S
@@ -3003,7 +3006,7 @@ export const serializable: {
    * @category combinators
    * @since 4.0.0
    */
-  <R extends Atom<any>, S extends Schema.Codec<Type<R>, any>>(
+  <R extends Atom<any>, S extends Schema.ConstraintCodec<Type<R>, any>>(
     self: R,
     options: {
       readonly key: string
@@ -3012,7 +3015,7 @@ export const serializable: {
   ): R & Serializable<S>
 } = dual(2, <R extends Atom<any>, A, I>(self: R, options: {
   readonly key: string
-  readonly schema: Schema.Codec<A, I>
+  readonly schema: Schema.ConstraintCodec<A, I>
 }): R & Serializable<any> => {
   const codecJson = Schema.toCodecJson(options.schema)
   return Object.assign(Object.create(Object.getPrototypeOf(self)), {