@effect-app/infra 0.198.2 → 0.199.2

package/src/api/routing/makeRequestHandler.ts

@@ -1,15 +1,19 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/ban-types */
 import type { EnforceNonEmptyRecord } from "@effect-app/core/utils"
-import { pretty } from "@effect-app/core/utils"
+import { copy, pretty } from "@effect-app/core/utils"
 import { snipString } from "@effect-app/infra/api/util"
 import { reportError } from "@effect-app/infra/errorReporter"
 import type { ValidationError } from "@effect-app/infra/errors"
 import type { RequestContextContainer } from "@effect-app/infra/services/RequestContextContainer"
 import type { ContextMapContainer } from "@effect-app/infra/services/Store/ContextMapContainer"
-import type { REST, StructFields } from "effect-app/schema"
-import type { HttpRequestError } from "../http.js"
-import { HttpBody, HttpRouteContext, HttpServerRequest, HttpServerResponse } from "../http.js"
+import type { Layer } from "effect-app"
+import { Effect, FiberRef, Option, S } from "effect-app"
+import type { HttpServerError } from "effect-app/http"
+import { HttpBody, HttpRouter, HttpServerRequest, HttpServerResponse } from "effect-app/http"
+import { NonEmptyString255 } from "effect-app/schema"
+import type { REST, Schema, StructFields } from "effect-app/schema"
+import { updateRequestContext } from "../setupRequest.js"
 import { makeRequestParsers, parseRequestParams } from "./base.js"
 import type { RequestHandler, RequestHandlerBase } from "./base.js"
 
@@ -90,16 +94,16 @@ export function makeRequestHandler<
     Config
   >,
   errorHandler: <R>(
-    req: HttpServerRequest,
-    res: HttpServerResponse,
-    r2: Effect<HttpServerResponse, ValidationError | ResE | MiddlewareE, R>
-  ) => Effect<HttpServerResponse, never, RErr | R>,
+    req: HttpServerRequest.ServerRequest,
+    res: HttpServerResponse.ServerResponse,
+    r2: Effect<HttpServerResponse.ServerResponse, ValidationError | ResE | MiddlewareE, R>
+  ) => Effect<HttpServerResponse.ServerResponse, never, RErr | R>,
   middlewareLayer?: Layer<PR, MiddlewareE, R2>
 ): Effect<
-  HttpServerResponse,
-  HttpRequestError,
-  | HttpRouteContext
-  | HttpServerRequest
+  HttpServerResponse.ServerResponse,
+  HttpServerError.RequestError,
+  | HttpRouter.RouteContext
+  | HttpServerRequest.ServerRequest
   | RequestContextContainer
   | ContextMapContainer
   | RErr
@@ -108,16 +112,16 @@ export function makeRequestHandler<
 > {
   const { Request, Response, h: handle } = handler
 
-  const response: REST.ReqRes<any, any, any> = Response ? Response : Void
+  const response: REST.ReqRes<any, any, any> = Response ? Response : S.void
   const resp = response as typeof response & { struct?: Schema<any, any, any> }
   // TODO: consider if the alternative of using the struct schema is perhaps just better.
   const encoder = "struct" in resp && resp.struct
-    ? resp.struct.encode
+    ? S.encode(resp.struct)
     // ? (i: any) => {
-    //   if (i instanceof (response as any)) return response.encodeSync(i)
-    //   else return response.encodeSync(new (response as any)(i))
+    //   if (i instanceof (response as any)) return S.encodeSync(response)(i)
+    //   else return S.encodeSync(response)(new (response as any)(i))
     // }
-    : resp.encode
+    : S.encode(resp)
   // const encodeResponse = adaptResponse
   //   ? (req: ReqA) => Encoder.for(adaptResponse(req))
   //   : () => encoder
@@ -125,12 +129,16 @@ export function makeRequestHandler<
   const requestParsers = makeRequestParsers(Request)
   const parseRequest = parseRequestParams(requestParsers)
 
-  const getParams = Effect
-    .all({
-      rcx: HttpRouteContext,
-      req: HttpServerRequest.flatMap((req) => req.json.map((body) => ({ body, headers: req.headers })))
-    })
-    .map((
+  const getParams = Effect.map(
+    Effect
+      .all({
+        rcx: HttpRouter.RouteContext,
+        req: Effect.flatMap(
+          HttpServerRequest.ServerRequest,
+          (req) => req.json.pipe(Effect.map((body) => ({ body, headers: req.headers })))
+        )
+      }),
+    (
       { rcx, req }
     ) => ({
       params: rcx.params,
@@ -138,140 +146,162 @@ export function makeRequestHandler<
       body: req.body,
       headers: req.headers,
       cookies: {} // req.cookies
-    }))
+    })
+  )
 
   return Effect
     .gen(function*($) {
-      const req = yield* $(HttpServerRequest)
+      const req = yield* $(HttpServerRequest.ServerRequest)
       const res = HttpServerResponse
         .empty()
-        .pipe((_) => req.method === "GET" ? _.setHeader("Cache-Control", "no-store") : _)
+        .pipe((_) => req.method === "GET" ? HttpServerResponse.setHeader(_, "Cache-Control", "no-store") : _)
 
       const pars = yield* $(getParams)
 
-      const settings = yield* $(RequestSettings.get)
+      const settings = yield* $(FiberRef.get(RequestSettings))
 
       const eff =
         // TODO: we don;t have access to user id here cause context is not yet created
         Effect
           .logInfo("Incoming request")
-          .annotateLogs({
-            method: req.method,
-            path: req.originalUrl,
-            ...(settings.verbose
-              ? {
-                reqPath: pars.params.$$.pretty,
-                reqQuery: pars.query.$$.pretty,
-                reqBody: pretty(pars.body),
-                reqCookies: pretty(pars.cookies),
-                reqHeaders: pretty(pars.headers)
-              }
-              : undefined)
-          })
-          .andThen(
-            Effect.suspend(() => {
-              const handleRequest = parseRequest(pars)
-                .map(({ body, path, query }) => {
-                  const hn = {
-                    ...body.value as any,
-                    ...query.value as any,
-                    ...path.value as any
-                  } as unknown as ReqA
-                  return hn
-                })
-                .flatMap((parsedReq) =>
-                  handle(parsedReq as any)
-                    .provideService(handler.Request.Tag, parsedReq as any)
-                    .flatMap(encoder)
-                    .map((r) =>
-                      res
-                        .setBody(HttpBody.unsafeJson(r))
-                        .setStatus(r === undefined ? 204 : 200)
-                    )
-                ) as Effect<
-                  HttpServerResponse,
-                  ValidationError | ResE,
-                  Exclude<R, EnforceNonEmptyRecord<M>>
-                >
+          .pipe(
+            Effect.annotateLogs({
+              method: req.method,
+              path: req.originalUrl,
+              ...(settings.verbose
+                ? {
+                  reqPath: pretty(pars.params),
+                  reqQuery: pretty(pars.query),
+                  reqBody: pretty(pars.body),
+                  reqCookies: pretty(pars.cookies),
+                  reqHeaders: pretty(pars.headers)
+                }
+                : undefined)
+            }),
+            Effect
+              .andThen(
+                Effect.suspend(() => {
+                  const handleRequest = parseRequest(pars)
+                    .pipe(
+                      Effect.map(({ body, path, query }) => {
+                        const hn = {
+                          ...body.pipe(Option.getOrUndefined) ?? {},
+                          ...query.pipe(Option.getOrUndefined) ?? {},
+                          ...path.pipe(Option.getOrUndefined) ?? {}
+                        } as unknown as ReqA
+                        return hn
+                      }),
+                      Effect
+                        .flatMap((parsedReq) =>
+                          handle(parsedReq)
+                            .pipe(
+                              Effect.provideService(handler.Request.Tag, parsedReq as any),
+                              Effect
+                                .flatMap(encoder),
+                              Effect
+                                .map((r) =>
+                                  res.pipe(
+                                    HttpServerResponse.setBody(HttpBody.unsafeJson(r)),
+                                    HttpServerResponse.setStatus(r === undefined ? 204 : 200)
+                                  )
+                                )
+                            )
+                        )
+                    ) as Effect<
+                      HttpServerResponse.ServerResponse,
+                      ValidationError | ResE,
+                      Exclude<R, EnforceNonEmptyRecord<M>>
+                    >
 
-              // Commands should not be interruptable.
-              const r = req.method !== "GET" ? handleRequest.uninterruptible : handleRequest // .instrument("Performance.RequestResponse")
-              const r2 = middlewareLayer
-                ? r.provide(middlewareLayer)
-                // PR is not relevant here
-                : (r as Effect<
-                  HttpServerResponse,
-                  ResE | MiddlewareE | ValidationError,
-                  Exclude<Exclude<R, EnforceNonEmptyRecord<M>>, PR>
-                >)
-              return errorHandler(
-                req,
-                res,
-                r2
-              )
-            })
-          )
-          .catchAllCause((cause) =>
+                  // Commands should not be interruptable.
+                  const r = req.method !== "GET" ? Effect.uninterruptible(handleRequest) : handleRequest // .instrument("Performance.RequestResponse")
+                  const r2 = middlewareLayer
+                    ? Effect.provide(r, middlewareLayer)
+                    // PR is not relevant here
+                    : (r as Effect<
+                      HttpServerResponse.ServerResponse,
+                      ResE | MiddlewareE | ValidationError,
+                      Exclude<Exclude<R, EnforceNonEmptyRecord<M>>, PR>
+                    >)
+                  return errorHandler(
+                    req,
+                    res,
+                    r2
+                  )
+                })
+              ),
             Effect
-              .sync(() => res.setStatus(500))
-              .tap((res) =>
+              .catchAllCause((cause) =>
                 Effect
-                  .all([
-                    reportError("request")(cause, {
-                      path: req.originalUrl,
-                      method: req.method
-                    }),
-                    Effect.suspend(() => {
-                      const headers = res.headers
-                      return Effect
-                        .logError("Finished request", cause)
-                        .annotateLogs({
-                          method: req.method,
-                          path: req.originalUrl,
-                          statusCode: res.status.toString(),
+                  .sync(() => HttpServerResponse.setStatus(res, 500))
+                  .pipe(Effect
+                    .tap((res) =>
+                      Effect
+                        .all([
+                          reportError("request")(cause, {
+                            path: req.originalUrl,
+                            method: req.method
+                          }),
+                          Effect.suspend(() => {
+                            const headers = res.headers
+                            return Effect
+                              .logError("Finished request", cause)
+                              .pipe(Effect.annotateLogs({
+                                method: req.method,
+                                path: req.originalUrl,
+                                statusCode: res.status.toString(),
 
-                          reqPath: pars.params.$$.pretty,
-                          reqQuery: pars.query.$$.pretty,
-                          reqBody: pretty(pars.body),
-                          reqCookies: pretty(pars.cookies),
-                          reqHeaders: pretty(pars.headers),
+                                reqPath: pretty(pars.params),
+                                reqQuery: pretty(pars.query),
+                                reqBody: pretty(pars.body),
+                                reqCookies: pretty(pars.cookies),
+                                reqHeaders: pretty(pars.headers),
 
-                          resHeaders: Object
-                            .entries(headers)
-                            .reduce((prev, [key, value]) => {
-                              prev[key] = value && typeof value === "string" ? snipString(value) : value
-                              return prev
-                            }, {} as Record<string, any>)
-                            .$$
-                            .pretty
-                        })
-                    })
-                  ], { concurrency: "inherit" })
-              )
-              .tapErrorCause((cause) => Effect.sync(() => console.error("Error occurred while reporting error", cause)))
-          )
-          .tap((res) =>
+                                resHeaders: pretty(
+                                  Object
+                                    .entries(headers)
+                                    .reduce((prev, [key, value]) => {
+                                      prev[key] = value && typeof value === "string" ? snipString(value) : value
+                                      return prev
+                                    }, {} as Record<string, any>)
+                                )
+                              }))
+                          })
+                        ], { concurrency: "inherit" })
+                    ))
+                  .pipe(
+                    Effect.tapErrorCause((cause) =>
+                      Effect.sync(() => console.error("Error occurred while reporting error", cause))
+                    )
+                  )
+              ),
             Effect
-              .logInfo("Finished request")
-              .annotateLogs({
-                method: req.method,
-                path: req.originalUrl,
-                statusCode: res.status.toString(),
-                ...(settings.verbose
-                  ? {
-                    resHeaders: pretty(res.headers)
-                  }
-                  : undefined)
-              })
+              .tap((res) =>
+                Effect
+                  .logInfo("Finished request")
+                  .pipe(Effect.annotateLogs({
+                    method: req.method,
+                    path: req.originalUrl,
+                    statusCode: res.status.toString(),
+                    ...(settings.verbose
+                      ? {
+                        resHeaders: pretty(res.headers)
+                      }
+                      : undefined)
+                  }))
+              )
           )
 
       return yield* $(eff)
     })
-    .updateRequestContext((_) =>
-      _.$$.copy({
-        name: NonEmptyString255(
-          handler.name
-        )
-      })
+    .pipe((_) =>
+      updateRequestContext(
+        _,
+        copy((_) => ({
+          name: NonEmptyString255(
+            handler.name
+          )
+        }))
+      )
     )
 }

package/src/api/routing/match.ts

@@ -1,16 +1,18 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/ban-types */
-import { type RouteDescriptorAny } from "@effect-app/infra/api/express/schema/routing"
 import type { ValidationError } from "@effect-app/infra/errors"
 import type { StructFields } from "effect-app/schema"
+import { type RouteDescriptorAny } from "./schema/routing.js"
 import type {} from "effect-app/utils"
-import { HttpRouter } from "../http.js"
-import type { HttpRouteContext, HttpServerRequest, HttpServerResponse } from "../http.js"
+import type { Layer, Ref, Scope } from "effect-app"
+import { Context, Effect } from "effect-app"
+import { HttpRouter } from "effect-app/http"
+import type { HttpServerRequest, HttpServerResponse } from "effect-app/http"
 import type { RequestHandler } from "./base.js"
 import { makeRequestHandler } from "./makeRequestHandler.js"
 import type { Middleware } from "./makeRequestHandler.js"
 
-export const RouteDescriptors = GenericTag<Ref<RouteDescriptorAny[]>>("@services/RouteDescriptors")
+export const RouteDescriptors = Context.GenericTag<Ref<RouteDescriptorAny[]>>("@services/RouteDescriptors")
 
 export function match<
   R,
@@ -49,10 +51,14 @@ export function match<
     Config
   >,
   errorHandler: <R>(
-    req: HttpServerRequest,
-    res: HttpServerResponse,
-    r2: Effect<HttpServerResponse, ValidationError | MiddlewareE | ResE, R>
-  ) => Effect<HttpServerResponse, never, Exclude<RErr | R, HttpServerRequest | HttpRouteContext | Scope>>,
+    req: HttpServerRequest.ServerRequest,
+    res: HttpServerResponse.ServerResponse,
+    r2: Effect<HttpServerResponse.ServerResponse, ValidationError | MiddlewareE | ResE, R>
+  ) => Effect<
+    HttpServerResponse.ServerResponse,
+    never,
+    Exclude<RErr | R, HttpServerRequest.ServerRequest | HttpRouter.RouteContext | Scope>
+  >,
   middleware?: Middleware<
     R,
     M,

package/src/api/{express → routing}/schema/jwt.ts

@@ -2,24 +2,25 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/ban-types */
 import type { ParseIssue } from "@effect/schema/ParseResult"
+import type { Effect } from "effect-app"
 import * as S from "effect-app/schema"
 import { jwtDecode, type JwtDecodeOptions } from "jwt-decode"
 
 export const parseJwt = <R, I, A>(
-  schema: Schema<A, I, R>,
+  schema: S.Schema<A, I, R>,
   options?: JwtDecodeOptions | undefined
-): Schema<A, string, R> =>
+): S.Schema<A, string, R> =>
   S
     .transformOrFail(
       S.string,
       S.unknown,
       (s, __, ast) =>
-        ParseResult.try({
+        S.ParseResult.try({
           try: () => jwtDecode(s, options),
-          catch: (e: any) => ParseResult.type(ast, s, e?.message)
+          catch: (e: any) => S.ParseResult.type(ast, s, e?.message)
         }),
       (_): Effect<string, ParseIssue> => {
         throw new Error("not implemented")
       }
     )
-    .compose(schema, { strict: false })
+    .pipe(S.compose(schema, { strict: false }))

package/src/api/{express → routing}/schema/routing.ts

@@ -1,5 +1,6 @@
 /* eslint-disable @typescript-eslint/ban-types */
 /* eslint-disable @typescript-eslint/no-explicit-any */
+import type { Context } from "effect-app"
 import type { REST } from "effect-app/schema"
 
 export type Request<
@@ -19,7 +20,7 @@ export type Request<
   Body?: REST.ReqRes<BodyA, unknown, any>
   Query?: REST.ReqRes<QueryA, Record<string, string>, any>
   Headers?: REST.ReqRes<HeaderA, Record<string, string>, any>
-  Tag: Tag<M, M>
+  Tag: Context.Tag<M, M>
 }
 
 export interface RouteRequestHandler<

package/src/api/setupRequest.ts

@@ -1,6 +1,8 @@
+import { NonEmptyString255 } from "@effect-app/schema"
+import { Effect, Layer, pipe } from "effect-app"
 import { RequestId } from "effect-app/ids"
 import { RequestContext } from "../RequestContext.js"
-import { RequestContextContainer } from "../services/RequestContextContainer.js"
+import { RequestContextContainer, spanAttributes } from "../services/RequestContextContainer.js"
 import { ContextMapContainer } from "../services/Store/ContextMapContainer.js"
 
 function makeInternalRequestContext(name: string) {
@@ -16,35 +18,39 @@ function makeInternalRequestContext(name: string) {
 }
 
 const withRequestSpan = <R, E, A>(f: Effect<A, E, R>) =>
-  RequestContextContainer
-    .get
-    .andThen((ctx) =>
-      f
-        .withSpan("request", { attributes: ctx.spanAttributes })
+  Effect.andThen(
+    RequestContextContainer
+      .get,
+    (ctx) =>
+      f.pipe(
+        Effect.withSpan("request", { attributes: spanAttributes(ctx) }),
         // request context info is picked up directly in the logger for annotations.
-        .withLogSpan("request")
-    )
+        Effect.withLogSpan("request")
+      )
+  )
 
-const setupContextMap = ContextMapContainer.andThen((_) => _.start).toLayerDiscard
+const setupContextMap = Effect.andThen(ContextMapContainer, (_) => _.start).pipe(Layer.effectDiscard)
 
 // const RequestContextLiveFromRequestContext = (requestContext: RequestContext) =>
 //   RequestContext.Tag.makeLayer(requestContext)
 // memoization problem
 // const RequestContextLive = RequestContextContainer.get.toLayer(RequestContext.Tag)
 const RequestContextStartLiveFromRequestContext = (requestContext: RequestContext) =>
-  setupContextMap
+  Layer.provideMerge(
+    setupContextMap,
     // .provideMerge(RequestContextLiveFromRequestContext(requestContext))
-    .provideMerge(
-      RequestContextContainer
-        .andThen((_) => _.start(requestContext))
-        .toLayerDiscard
-    )
+    Effect
+      .andThen(RequestContextContainer, (_) => _.start(requestContext))
+      .pipe(Layer.effectDiscard)
+  )
 
 const RequestContextStartLive = (requestContext: RequestContext | string) =>
   typeof requestContext === "string"
-    ? makeInternalRequestContext(requestContext)
-      .andThen(RequestContextStartLiveFromRequestContext)
-      .unwrapLayer
+    ? pipe(
+      makeInternalRequestContext(requestContext),
+      Effect.andThen(RequestContextStartLiveFromRequestContext),
+      Layer.unwrapEffect
+    )
     : RequestContextStartLiveFromRequestContext(requestContext)
 
 /**
@@ -52,18 +58,18 @@ const RequestContextStartLive = (requestContext: RequestContext | string) =>
  */
 export function setupRequestContext<R, E, A>(self: Effect<A, E, R>, requestContext: RequestContext | string) {
   return self
-    .pipe(withRequestSpan)
-    .provide(RequestContextStartLive(requestContext))
+    .pipe(
+      withRequestSpan,
+      Effect.provide(RequestContextStartLive(requestContext))
+    )
 }
 
 const UpdateRequestContextLive = (f: (rc: RequestContext) => RequestContext) =>
-  RequestContextContainer.andThen((rcc) => rcc.update(f)).toLayerDiscard
+  Effect.andThen(RequestContextContainer, (rcc) => rcc.update(f)).pipe(Layer.effectDiscard)
 
 /**
  * @tsplus fluent effect/io/Effect updateRequestContext
  */
 export function updateRequestContext<R, E, A>(self: Effect<A, E, R>, f: (rc: RequestContext) => RequestContext) {
-  return self
-    // .provideServiceEffect(RequestContext.Tag, RequestContextContainer.get)
-    .provide(UpdateRequestContextLive(f))
+  return Effect.provide(self, UpdateRequestContextLive(f))
 }

package/src/errorReporter.ts

@@ -1,5 +1,6 @@
 import { dropUndefined } from "@effect-app/core/utils"
 import * as Sentry from "@sentry/node"
+import { Cause, Effect, Option } from "effect-app"
 import { CauseException } from "./errors.js"
 import { RequestContextContainer } from "./services/RequestContextContainer.js"
 
@@ -8,8 +9,8 @@ export function reportError(
 ) {
   return (cause: Cause<unknown>, extras?: Record<string, unknown>) =>
     Effect.gen(function*($) {
-      if (cause.isInterrupted()) {
-        yield* $(Effect.logDebug("Interrupted").annotateLogs("extras", JSON.stringify(extras ?? {})))
+      if (Cause.isInterrupted(cause)) {
+        yield* $(Effect.logDebug("Interrupted").pipe(Effect.annotateLogs("extras", JSON.stringify(extras ?? {}))))
         return
       }
       yield* $(reportSentry(cause, name, extras))
@@ -17,11 +18,11 @@ export function reportError(
       yield* $(
         Effect
           .logError("Reporting error", cause)
-          .annotateLogs(dropUndefined({
+          .pipe(Effect.annotateLogs(dropUndefined({
             extras,
             __cause__: error.toJSON(),
             __error_name__: name
-          }))
+          })))
       )
     })
 }
@@ -31,15 +32,15 @@ function reportSentry(
   name: string,
   extras: Record<string, unknown> | undefined
 ) {
-  return RequestContextContainer.getOption.map((ctx) => {
-    const context = ctx.value!
+  return RequestContextContainer.getOption.pipe(Effect.map((ctx) => {
+    const context = Option.getOrUndefined(ctx)
     const scope = new Sentry.Scope()
     if (context) scope.setContext("context", context as unknown as Record<string, unknown>)
     if (extras) scope.setContext("extras", extras)
     const error = new CauseException(cause, name)
     scope.setContext("error", error.toJSON() as any)
     Sentry.captureException(error, scope)
-  })
+  }))
 }
 
 export function logError<E>(
@@ -47,19 +48,19 @@ export function logError<E>(
 ) {
   return (cause: Cause<E>, extras?: Record<string, unknown>) =>
     Effect.gen(function*($) {
-      if (cause.isInterrupted()) {
-        yield* $(Effect.logDebug("Interrupted").annotateLogs(dropUndefined({ extras })))
+      if (Cause.isInterrupted(cause)) {
+        yield* $(Effect.logDebug("Interrupted").pipe(Effect.annotateLogs(dropUndefined({ extras }))))
         return
       }
       const error = new CauseException(cause, name)
       yield* $(
         Effect
           .logWarning("Logging error", cause)
-          .annotateLogs(dropUndefined({
+          .pipe(Effect.annotateLogs(dropUndefined({
             extras,
             __cause__: error.toJSON(),
             __error_name__: name
-          }))
+          })))
       )
     })
 }

package/src/errors.ts

@@ -1,4 +1,5 @@
 /* eslint-disable @typescript-eslint/ban-types */
+import { Cause } from "effect-app"
 import { makeFiberFailure } from "effect/Runtime"
 
 export * from "effect-app/client/errors"

package/src/filter/types/path/index.ts

@@ -1,7 +1,7 @@
 /** Re-export public API */
 
-export { PathString } from "./common.js"
-export {
+export type { PathString } from "./common.js"
+export type {
   ArrayPath,
   FieldArrayPath,
   FieldArrayPathValue,