@effect-app/infra 0.198.1 → 0.199.0

package/src/api/routing/base.ts

@@ -5,10 +5,11 @@ import * as S from "effect-app/schema"
 
 import type { EnforceNonEmptyRecord } from "@effect-app/core/utils"
 import { ValidationError } from "@effect-app/infra/errors"
+import type { Context } from "effect-app"
+import { Cause, Effect, Exit, Option } from "effect-app"
+import type { HttpRouter, HttpServerError } from "effect-app/http"
 import type { REST, StructFields } from "effect-app/schema"
 import type { Simplify } from "effect/Types"
-import type express from "express"
-import type { HttpRequestError, HttpRoute } from "../http.js"
 
 export type Flatten<T extends object> = object extends T ? object : {
   [K in keyof T]-?: (
@@ -53,7 +54,7 @@ export type RouteMatch<
   // PR = never
   Effect<
     // RouteDescriptor<R, PathA, CookieA, QueryA, BodyA, HeaderA, ReqA, ResA, SupportedErrors, Methods>
-    HttpRoute<Exclude<Exclude<R, EnforceNonEmptyRecord<M>>, PR>, HttpRequestError>
+    HttpRouter.Route<Exclude<Exclude<R, EnforceNonEmptyRecord<M>>, PR>, HttpServerError.RequestError>
   >
 
 export interface ReqHandler<
@@ -125,6 +126,20 @@ export function parseRequestParams<
 >(
   parsers: RequestParsers<PathA, CookieA, QueryA, BodyA, HeaderA>
 ) {
+  const handleParse = <A, E, R>(effect: Effect<A, E, R>) =>
+    effect.pipe(
+      Effect.exit,
+      Effect
+        .flatMap((_) =>
+          Exit.isFailure(_) && !Cause.isFailure(_.cause)
+            ? (Effect.failCauseSync(() => _.cause) as Effect<never, ValidationError>)
+            : Effect.sync(() =>
+              Exit.isSuccess(_)
+                ? { _tag: "Success" as const, value: _.value }
+                : { _tag: "Failure", errors: Cause.failures(_.cause) }
+            )
+        )
+    )
   return (
     { body, cookies, headers, params, query }: {
       body: unknown
@@ -138,93 +153,49 @@ export function parseRequestParams<
       .all({
         body: parsers
           .parseBody(body)
-          .exit
-          .flatMap((_) =>
-            _.isFailure() && !_.cause.isFailure()
-              ? (Effect.failCauseSync(() => _.cause) as Effect<never, ValidationError>)
-              : Effect.sync(() =>
-                _.isSuccess()
-                  ? { _tag: "Success" as const, value: _.value }
-                  : { _tag: "Failure", errors: _.cause.failures }
-              )
-          ),
+          .pipe(handleParse),
         cookie: parsers
           .parseCookie(cookies)
-          .exit
-          .flatMap((_) =>
-            _.isFailure() && !_.cause.isFailure()
-              ? (Effect.failCauseSync(() => _.cause) as Effect<never, ValidationError>)
-              : Effect.sync(() =>
-                _.isSuccess()
-                  ? { _tag: "Success" as const, value: _.value }
-                  : { _tag: "Failure", errors: _.cause.failures }
-              )
-          ),
+          .pipe(handleParse),
         headers: parsers
           .parseHeaders(headers)
-          .exit
-          .flatMap((_) =>
-            _.isFailure() && !_.cause.isFailure()
-              ? (Effect.failCauseSync(() => _.cause) as Effect<never, ValidationError>)
-              : Effect.sync(() =>
-                _.isSuccess()
-                  ? { _tag: "Success" as const, value: _.value }
-                  : { _tag: "Failure", errors: _.cause.failures }
-              )
-          ),
+          .pipe(handleParse),
         query: parsers
           .parseQuery(query)
-          .exit
-          .flatMap((_) =>
-            _.isFailure() && !_.cause.isFailure()
-              ? (Effect.failCauseSync(() => _.cause) as Effect<never, ValidationError>)
-              : Effect.sync(() =>
-                _.isSuccess()
-                  ? { _tag: "Success" as const, value: _.value }
-                  : { _tag: "Failure", errors: _.cause.failures }
-              )
-          ),
+          .pipe(handleParse),
         path: parsers
           .parsePath(params)
-          .exit
-          .flatMap((_) =>
-            _.isFailure() && !_.cause.isFailure()
-              ? (Effect.failCauseSync(() => _.cause) as Effect<never, ValidationError>)
-              : Effect.sync(() =>
-                _.isSuccess()
-                  ? { _tag: "Success" as const, value: _.value }
-                  : { _tag: "Failure", errors: _.cause.failures }
-              )
-          )
+          .pipe(handleParse)
       })
-      .flatMap(({ body, cookie, headers, path, query }) => {
-        const errors: unknown[] = []
-        if (body._tag === "Failure") {
-          errors.push(makeError("body")(body.errors))
-        }
-        if (cookie._tag === "Failure") {
-          errors.push(makeError("cookie")(cookie.errors))
-        }
-        if (headers._tag === "Failure") {
-          errors.push(makeError("headers")(headers.errors))
-        }
-        if (path._tag === "Failure") {
-          errors.push(makeError("path")(path.errors))
-        }
-        if (query._tag === "Failure") {
-          errors.push(makeError("query")(query.errors))
-        }
-        if (errors.length) {
-          return new ValidationError({ errors })
-        }
-        return Effect.sync(() => ({
-          body: body.value!,
-          cookie: cookie.value!,
-          headers: headers.value!,
-          path: path.value!,
-          query: query.value!
+      .pipe(Effect
+        .flatMap(({ body, cookie, headers, path, query }) => {
+          const errors: unknown[] = []
+          if (body._tag === "Failure") {
+            errors.push(makeError("body")(body.errors))
+          }
+          if (cookie._tag === "Failure") {
+            errors.push(makeError("cookie")(cookie.errors))
+          }
+          if (headers._tag === "Failure") {
+            errors.push(makeError("headers")(headers.errors))
+          }
+          if (path._tag === "Failure") {
+            errors.push(makeError("path")(path.errors))
+          }
+          if (query._tag === "Failure") {
+            errors.push(makeError("query")(query.errors))
+          }
+          if (errors.length) {
+            return new ValidationError({ errors })
+          }
+          return Effect.sync(() => ({
+            body: body.value!,
+            cookie: cookie.value!,
+            headers: headers.value!,
+            path: path.value!,
+            query: query.value!
+          }))
         }))
-      })
 }
 
 // // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -249,20 +220,6 @@ function makeError(type: string) {
   return (e: unknown) => [{ type, errors: decodeErrors(e) }]
 }
 
-export function respondSuccess<ReqA, A, E>(
-  encodeResponse: (req: ReqA) => Encode<A, E>
-) {
-  return (req: ReqA, res: express.Response) =>
-    flow(encodeResponse(req), Effect.succeed, (_) =>
-      _.flatMap((r) =>
-        Effect.sync(() => {
-          r === undefined
-            ? res.status(204).send()
-            : res.status(200).send(JSON.stringify(r))
-        })
-      ))
-}
-
 export function makeRequestParsers<
   R,
   M,
@@ -299,42 +256,52 @@ export function makeRequestParsers<
   const ph = Effect.sync(() =>
     Option
       .fromNullable(Request.Headers)
-      .map((s) => s as unknown as Schema<any>)
-      .map(S.decodeUnknown)
+      .pipe(
+        Option.map((s) => s as unknown as S.Schema<any>),
+        Option.map(S.decodeUnknown)
+      )
   )
-  const parseHeaders = (u: unknown) => ph.flatMapOpt((d) => d(u))
+  const parseHeaders = (u: unknown) => Effect.flatMapOption(ph, (d) => d(u))
 
   const pq = Effect.sync(() =>
     Option
       .fromNullable(Request.Query)
-      .map((s) => s as unknown as Schema<any>)
-      .map(S.decodeUnknown)
+      .pipe(
+        Option.map((s) => s as unknown as S.Schema<any>),
+        Option.map(S.decodeUnknown)
+      )
   )
-  const parseQuery = (u: unknown) => pq.flatMapOpt((d) => d(u))
+  const parseQuery = (u: unknown) => Effect.flatMapOption(pq, (d) => d(u))
 
   const pb = Effect.sync(() =>
     Option
       .fromNullable(Request.Body)
-      .map((s) => s as unknown as Schema<any>)
-      .map(S.decodeUnknown)
+      .pipe(
+        Option.map((s) => s as unknown as S.Schema<any>),
+        Option.map(S.decodeUnknown)
+      )
   )
-  const parseBody = (u: unknown) => pb.flatMapOpt((d) => d(u))
+  const parseBody = (u: unknown) => Effect.flatMapOption(pb, (d) => d(u))
 
   const pp = Effect.sync(() =>
     Option
       .fromNullable(Request.Path)
-      .map((s) => s as unknown as Schema<any>)
-      .map(S.decodeUnknown)
+      .pipe(
+        Option.map((s) => s as unknown as S.Schema<any>),
+        Option.map(S.decodeUnknown)
+      )
   )
-  const parsePath = (u: unknown) => pp.flatMapOpt((d) => d(u))
+  const parsePath = (u: unknown) => Effect.flatMapOption(pp, (d) => d(u))
 
   const pc = Effect.sync(() =>
     Option
       .fromNullable(Request.Cookie)
-      .map((s) => s as unknown as Schema<any>)
-      .map(S.decodeUnknown)
+      .pipe(
+        Option.map((s) => s as unknown as S.Schema<any>),
+        Option.map(S.decodeUnknown)
+      )
   )
-  const parseCookie = (u: unknown) => pc.flatMapOpt((d) => d(u))
+  const parseCookie = (u: unknown) => Effect.flatMapOption(pc, (d) => d(u))
 
   return {
     parseBody,
@@ -382,7 +349,7 @@ export type Request<
   Body?: BodyA
   Query?: QueryA
   Headers?: HeaderA
-  Tag: Tag<M, M>
+  Tag: Context.Tag<M, M>
   ReqA?: ReqA
 }
 

package/src/api/routing/defaultErrorHandler.ts

@@ -1,4 +1,7 @@
 import { logError } from "@effect-app/infra/errorReporter"
+import type { Schema } from "@effect-app/schema"
+import { setBody, setStatus } from "@effect/platform/Http/ServerResponse"
+import { Cause, Data, Effect, S, Schedule } from "effect-app"
 import type { SupportedErrors } from "effect-app/client/errors"
 import {
   InvalidStateError,
@@ -8,8 +11,7 @@ import {
   UnauthorizedError,
   ValidationError
 } from "effect-app/client/errors"
-import { HttpBody, HttpHeaders, type HttpServerRequest, type HttpServerResponse } from "../http.js"
-
+import { HttpBody, HttpHeaders, type HttpServerRequest, HttpServerResponse } from "effect-app/http"
 import type {
   InsufficientScopeError,
   InvalidRequestError,
@@ -28,73 +30,81 @@ export class JWTError extends Data.TaggedClass("JWTError")<{
 const logRequestError = logError("Request")
 
 export function defaultBasicErrorHandler<R>(
-  _req: HttpServerRequest,
-  res: HttpServerResponse,
-  r2: Effect<HttpServerResponse, ValidationError, R>
+  _req: HttpServerRequest.ServerRequest,
+  res: HttpServerResponse.ServerResponse,
+  r2: Effect<HttpServerResponse.ServerResponse, ValidationError, R>
 ) {
   const sendError = (code: number) => (body: unknown) =>
-    Effect.sync(() => res.setBody(HttpBody.unsafeJson(body)).setStatus(code))
-  return r2
-    .tapErrorCause((cause) => cause.isFailure() ? logRequestError(cause) : Effect.unit)
-    .catchTag("ValidationError", (err) => sendError(400)(err.errors))
-    // final catch all; expecting never so that unhandled known errors will show up
-    .catchAll((err: never) =>
-      Effect
-        .logError(
-          "Program error, compiler probably silenced, got an unsupported Error in Error Channel of Effect" + err
-        )
-        .map(() => err as unknown)
-        .flatMap(Effect.die)
-    )
+    Effect.sync(() => setBody(res, HttpBody.unsafeJson(body)).pipe(setStatus(code)))
+  return r2.pipe(
+    Effect.tapErrorCause((cause) => Cause.isFailure(cause) ? logRequestError(cause) : Effect.unit),
+    Effect.catchTag("ValidationError", (err) => sendError(400)(err.errors)),
+    Effect
+      // final catch all; expecting never so that unhandled known errors will show up
+      .catchAll((err: never) =>
+        Effect
+          .logError(
+            "Program error, compiler probably silenced, got an unsupported Error in Error Channel of Effect" + err
+          )
+          .pipe(
+            Effect.map(() => err as unknown),
+            Effect.flatMap(Effect.die)
+          )
+      )
+  )
 }
 
 const optimisticConcurrencySchedule = Schedule.once
   && Schedule.recurWhile<SupportedErrors | JWTError>((a) => a._tag === "OptimisticConcurrencyException")
 
 export function defaultErrorHandler<R>(
-  req: HttpServerRequest,
-  res: HttpServerResponse,
-  r2: Effect<HttpServerResponse, SupportedErrors | JWTError, R>
+  req: HttpServerRequest.ServerRequest,
+  res: HttpServerResponse.ServerResponse,
+  r2: Effect<HttpServerResponse.ServerResponse, SupportedErrors | JWTError, R>
 ) {
   const r3 = req.method === "PATCH"
-    ? r2.retry(optimisticConcurrencySchedule)
+    ? Effect.retry(r2, optimisticConcurrencySchedule)
     : r2
   const sendError = <R, From, To>(code: number, schema: Schema<To, From, R>) => (body: To) =>
-    schema
-      .encode(body)
-      .orDie
-      .andThen((body) =>
-        res
-          .setStatus(code)
-          .setBody(HttpBody.unsafeJson(body))
+    S
+      .encode(schema)(body)
+      .pipe(
+        Effect.orDie,
+        Effect.andThen((body) => res.pipe(setStatus(code), setBody(HttpBody.unsafeJson(body))))
       )
   return r3
-    .tapErrorCause((cause) => cause.isFailure() ? logRequestError(cause) : Effect.unit)
-    .catchTags({
-      "JWTError": (err) =>
-        Effect.succeed(
-          HttpServerResponse.unsafeJson({ message: err.error.message }, {
-            status: err
-              .error
-              .status,
-            headers: HttpHeaders.fromInput(err.error.headers)
-          })
-        ),
-      "ValidationError": sendError(400, ValidationError),
-      "NotFoundError": sendError(404, NotFoundError),
-      "NotLoggedInError": sendError(401, NotLoggedInError),
-      "UnauthorizedError": sendError(403, UnauthorizedError),
-      "InvalidStateError": sendError(422, InvalidStateError),
-      // 412 or 409.. https://stackoverflow.com/questions/19122088/which-http-status-code-to-use-to-reject-a-put-due-to-optimistic-locking-failure
-      "OptimisticConcurrencyException": sendError(412, OptimisticConcurrencyException)
-    })
-    // final catch all; expecting never so that unhandled known errors will show up
-    .catchAll((err: never) =>
+    .pipe(
+      Effect.tapErrorCause((cause) => Cause.isFailure(cause) ? logRequestError(cause) : Effect.unit),
+      Effect
+        .catchTags({
+          "JWTError": (err) =>
+            Effect.succeed(
+              HttpServerResponse.unsafeJson({ message: err.error.message }, {
+                status: err
+                  .error
+                  .status,
+                headers: HttpHeaders.fromInput(err.error.headers)
+              })
+            ),
+          "ValidationError": sendError(400, ValidationError),
+          "NotFoundError": sendError(404, NotFoundError),
+          "NotLoggedInError": sendError(401, NotLoggedInError),
+          "UnauthorizedError": sendError(403, UnauthorizedError),
+          "InvalidStateError": sendError(422, InvalidStateError),
+          // 412 or 409.. https://stackoverflow.com/questions/19122088/which-http-status-code-to-use-to-reject-a-put-due-to-optimistic-locking-failure
+          "OptimisticConcurrencyException": sendError(412, OptimisticConcurrencyException)
+        }),
       Effect
-        .logError(
-          "Program error, compiler probably silenced, got an unsupported Error in Error Channel of Effect" + err
+        // final catch all; expecting never so that unhandled known errors will show up
+        .catchAll((err: never) =>
+          Effect
+            .logError(
+              "Program error, compiler probably silenced, got an unsupported Error in Error Channel of Effect" + err
+            )
+            .pipe(
+              Effect.map(() => err as unknown),
+              Effect.flatMap(Effect.die)
+            )
         )
-        .map(() => err as unknown)
-        .flatMap(Effect.die)
     )
 }