@effect-app/infra 1.28.3 → 1.29.0

package/src/api/routing/makeRequestHandler.ts

@@ -1,343 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/* eslint-disable @typescript-eslint/ban-types */
-import type { EnforceNonEmptyRecord } from "@effect-app/core/utils"
-import { copy, pretty } from "@effect-app/core/utils"
-import { RequestFiberSet } from "@effect-app/infra-adapters/RequestFiberSet"
-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 { Struct } from "@effect/schema/Schema"
-import type { Layer } from "effect-app"
-import { Console, 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 } from "effect-app/schema"
-import { InfraLogger } from "../../logger.js"
-import { updateRequestContext } from "../setupRequest.js"
-import { makeRequestParsers, parseRequestParams } from "./base.js"
-import type { RequestHandler, RequestHandlerBase } from "./base.js"
-
-export const RequestSettings = FiberRef.unsafeMake({
-  verbose: false
-})
-
-export type Middleware<
-  R,
-  M,
-  PathA extends Struct.Fields,
-  CookieA extends Struct.Fields,
-  QueryA extends Struct.Fields,
-  BodyA extends Struct.Fields,
-  HeaderA extends Struct.Fields,
-  ReqA extends PathA & QueryA & BodyA,
-  ResA extends Struct.Fields,
-  ResE,
-  MiddlewareE,
-  PPath extends `/${string}`,
-  R2,
-  PR,
-  CTX,
-  Context,
-  Config
-> = (
-  handler: RequestHandler<
-    R,
-    M,
-    PathA,
-    CookieA,
-    QueryA,
-    BodyA,
-    HeaderA,
-    ReqA,
-    ResA,
-    ResE,
-    PPath,
-    CTX,
-    Context,
-    Config
-  >
-) => {
-  handler: RequestHandler<
-    R2 | PR | RequestContextContainer | ContextMapContainer | RequestFiberSet,
-    M,
-    PathA,
-    CookieA,
-    QueryA,
-    BodyA,
-    HeaderA,
-    ReqA,
-    ResA,
-    ResE,
-    PPath,
-    CTX,
-    Context,
-    Config
-  >
-  makeRequestLayer: Layer<PR, MiddlewareE, R2>
-}
-
-export function makeRequestHandler<
-  R,
-  M,
-  PathA extends Struct.Fields,
-  CookieA extends Struct.Fields,
-  QueryA extends Struct.Fields,
-  BodyA extends Struct.Fields,
-  HeaderA extends Struct.Fields,
-  ReqA extends PathA & QueryA & BodyA,
-  ResA extends Struct.Fields,
-  ResE,
-  MiddlewareE,
-  R2,
-  PR,
-  RErr,
-  PPath extends `/${string}`,
-  Config
->(
-  handler: RequestHandlerBase<
-    R,
-    M,
-    PathA,
-    CookieA,
-    QueryA,
-    BodyA,
-    HeaderA,
-    ReqA,
-    ResA,
-    ResE,
-    PPath,
-    Config
-  >,
-  errorHandler: <R>(
-    req: HttpServerRequest.HttpServerRequest,
-    res: HttpServerResponse.HttpServerResponse,
-    r2: Effect<HttpServerResponse.HttpServerResponse, ValidationError | ResE | MiddlewareE, R>
-  ) => Effect<HttpServerResponse.HttpServerResponse, never, RErr | R>,
-  middlewareLayer?: Layer<PR, MiddlewareE, R2>
-): Effect<
-  HttpServerResponse.HttpServerResponse,
-  HttpServerError.RequestError,
-  | HttpRouter.RouteContext
-  | HttpServerRequest.ParsedSearchParams
-  | HttpServerRequest.HttpServerRequest
-  | RequestContextContainer
-  | ContextMapContainer
-  | RequestFiberSet
-  | RErr
-  | Exclude<Exclude<R, EnforceNonEmptyRecord<M>>, PR>
-  | R2
-> {
-  const { Request, Response, h: handle } = handler
-
-  const response: REST.ReqRes<any, any, any> = Response ? Response : S.Void
-  const resp = response as typeof response & { fields?: Struct.Fields }
-  // TODO: consider if the alternative of using the struct schema is perhaps just better.
-  const encoder = "fields" in resp && resp.fields
-    ? S.encode(handler.rt === "raw" ? S.encodedSchema(S.Struct(resp.fields)) : S.Struct(resp.fields))
-    // ? (i: any) => {
-    //   if (i instanceof (response as any)) return S.encodeSync(response)(i)
-    //   else return S.encodeSync(response)(new (response as any)(i))
-    // }
-    : S.encode(handler.rt === "raw" ? S.encodedSchema(resp) : resp)
-  // const encodeResponse = adaptResponse
-  //   ? (req: ReqA) => Encoder.for(adaptResponse(req))
-  //   : () => encoder
-
-  const requestParsers = makeRequestParsers(Request)
-  const parseRequest = parseRequestParams(requestParsers)
-
-  const getParams = Effect.map(
-    Effect
-      .all({
-        rcx: HttpRouter.RouteContext,
-        searchParms: HttpServerRequest.ParsedSearchParams,
-        req: Effect.flatMap(
-          HttpServerRequest.HttpServerRequest,
-          (req) => req.json.pipe(Effect.map((body) => ({ body, headers: req.headers })))
-        )
-      }),
-    (
-      { rcx, req, searchParms }
-    ) => ({
-      params: rcx.params,
-      query: searchParms,
-      body: req.body,
-      headers: req.headers,
-      cookies: {} // req.cookies
-    })
-  )
-
-  return Effect
-    .gen(function*() {
-      const req = yield* HttpServerRequest.HttpServerRequest
-      const res = HttpServerResponse
-        .empty()
-        .pipe((_) => req.method === "GET" ? HttpServerResponse.setHeader(_, "Cache-Control", "no-store") : _)
-
-      const pars = yield* getParams
-
-      const settings = yield* FiberRef.get(RequestSettings)
-
-      const eff =
-        // TODO: we don;t have access to user id here cause context is not yet created
-        InfraLogger
-          .logInfo("Incoming request")
-          .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.tap((parsedReq) =>
-                        Effect.annotateCurrentSpan(
-                          "requestInput",
-                          Object.entries(parsedReq).reduce((prev, [key, value]: [string, unknown]) => {
-                            prev[key] = key === "password"
-                              ? "<redacted>"
-                              : typeof value === "string" || typeof value === "number" || typeof value === "boolean"
-                              ? typeof value === "string" && value.length > 256
-                                ? (value.substring(0, 253) + "...")
-                                : value
-                              : Array.isArray(value)
-                              ? `Array[${value.length}]`
-                              : value === null || value === undefined
-                              ? `${value}`
-                              : typeof value === "object" && value
-                              ? `Object[${Object.keys(value).length}]`
-                              : typeof value
-                            return prev
-                          }, {} as Record<string, string | number | boolean>)
-                        )
-                      ),
-                      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.HttpServerResponse,
-                      ValidationError | ResE,
-                      Exclude<R, EnforceNonEmptyRecord<M>>
-                    >
-
-                  const r = middlewareLayer
-                    ? Effect.provide(handleRequest, middlewareLayer)
-                    // PR is not relevant here
-                    : (handleRequest as Effect<
-                      HttpServerResponse.HttpServerResponse,
-                      ResE | MiddlewareE | ValidationError,
-                      Exclude<Exclude<R, EnforceNonEmptyRecord<M>>, PR>
-                    >)
-                  return errorHandler(
-                    req,
-                    res,
-                    r.pipe(Effect.andThen(RequestFiberSet.register))
-                  )
-                })
-              ),
-            Effect
-              .catchAllCause((cause) =>
-                Effect
-                  .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 InfraLogger
-                              .logError("Finished request", cause)
-                              .pipe(Effect.annotateLogs({
-                                method: req.method,
-                                path: req.originalUrl,
-                                statusCode: res.status.toString(),
-
-                                reqPath: pretty(pars.params),
-                                reqQuery: pretty(pars.query),
-                                reqBody: pretty(pars.body),
-                                reqCookies: pretty(pars.cookies),
-                                reqHeaders: pretty(pars.headers),
-
-                                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) => Console.error("Error occurred while reporting error", cause))
-                  )
-              ),
-            Effect
-              .tap((res) =>
-                InfraLogger
-                  .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
-    })
-    .pipe((_) =>
-      updateRequestContext(
-        _,
-        copy((_) => ({
-          name: NonEmptyString255(
-            handler.name
-          )
-        }))
-      )
-    )
-}

package/src/api/routing/match.ts

@@ -1,128 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/* eslint-disable @typescript-eslint/ban-types */
-import type { ValidationError } from "@effect-app/infra/errors"
-import { type RouteDescriptorAny } from "./schema/routing.js"
-import type {} from "effect-app/utils"
-import type { Struct } from "@effect/schema/Schema"
-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 = Context.GenericTag<Ref<RouteDescriptorAny[]>>("@services/RouteDescriptors")
-
-export function match<
-  R,
-  M,
-  PathA extends Struct.Fields,
-  CookieA extends Struct.Fields,
-  QueryA extends Struct.Fields,
-  BodyA extends Struct.Fields,
-  HeaderA extends Struct.Fields,
-  ReqA extends PathA & QueryA & BodyA,
-  ResA extends Struct.Fields,
-  ResE,
-  MiddlewareE,
-  PPath extends `/${string}`,
-  R2,
-  PR,
-  RErr,
-  CTX,
-  Context,
-  Config
->(
-  requestHandler: RequestHandler<
-    R,
-    M,
-    PathA,
-    CookieA,
-    QueryA,
-    BodyA,
-    HeaderA,
-    ReqA,
-    ResA,
-    ResE,
-    PPath,
-    CTX,
-    Context,
-    Config
-  >,
-  errorHandler: <R>(
-    req: HttpServerRequest.HttpServerRequest,
-    res: HttpServerResponse.HttpServerResponse,
-    r2: Effect<HttpServerResponse.HttpServerResponse, ValidationError | MiddlewareE | ResE, R>
-  ) => Effect<
-    HttpServerResponse.HttpServerResponse,
-    never,
-    Exclude<RErr | R, HttpServerRequest.HttpServerRequest | HttpRouter.RouteContext | Scope>
-  >,
-  middleware?: Middleware<
-    R,
-    M,
-    PathA,
-    CookieA,
-    QueryA,
-    BodyA,
-    HeaderA,
-    ReqA,
-    ResA,
-    ResE,
-    MiddlewareE,
-    PPath,
-    R2,
-    PR,
-    CTX,
-    Context,
-    Config
-  >
-) {
-  let middlewareLayer: Layer<PR, MiddlewareE, R2> | undefined = undefined
-  if (middleware) {
-    const { handler, makeRequestLayer } = middleware(requestHandler)
-    requestHandler = handler as any // todo
-    middlewareLayer = makeRequestLayer
-  }
-  return Effect.gen(function*() {
-    // const rdesc = yield* $(RouteDescriptors.flatMap((_) => _.get))
-
-    const handler = makeRequestHandler<
-      R,
-      M,
-      PathA,
-      CookieA,
-      QueryA,
-      BodyA,
-      HeaderA,
-      ReqA,
-      ResA,
-      ResE,
-      MiddlewareE,
-      R2,
-      PR,
-      RErr,
-      PPath,
-      Config
-    >(
-      requestHandler as any, // one argument if no middleware, 2 if has middleware. TODO: clean this shit up
-      errorHandler,
-      middlewareLayer
-    )
-
-    const route = HttpRouter.makeRoute(
-      requestHandler.Request.method,
-      requestHandler.Request.path,
-      handler,
-      { uninterruptible: requestHandler.Request.method !== "GET" } // we don't want commands to be interruptible
-    )
-    // TODO
-    // rdesc.push(makeRouteDescriptor(
-    //   requestHandler.Request.path,
-    //   requestHandler.Request.method,
-    //   requestHandler
-    // ))
-    return route
-  })
-}

package/src/api/routing/schema/routing.ts

@@ -1,237 +0,0 @@
-/* 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<
-  M,
-  PathA,
-  CookieA,
-  QueryA,
-  BodyA,
-  HeaderA,
-  ReqA extends PathA & QueryA & BodyA,
-  PPath extends `/${string}`
-> = REST.ReqRes<any, unknown, ReqA> & {
-  method: REST.SupportedMethods
-  path: PPath
-  Cookie?: REST.ReqRes<CookieA, Record<string, string>, any>
-  Path?: REST.ReqRes<PathA, Record<string, string>, any>
-  Body?: REST.ReqRes<BodyA, unknown, any>
-  Query?: REST.ReqRes<QueryA, Record<string, string>, any>
-  Headers?: REST.ReqRes<HeaderA, Record<string, string>, any>
-  Tag: Context.Tag<M, M>
-}
-
-export interface RouteRequestHandler<
-  M,
-  PathA,
-  CookieA,
-  QueryA,
-  BodyA,
-  HeaderA,
-  ReqA extends PathA & QueryA & BodyA,
-  ResA,
-  PPath extends `/${string}`
-> {
-  Request: Request<M, PathA, CookieA, QueryA, BodyA, HeaderA, ReqA, PPath>
-  Response?: REST.ReqRes<ResA, unknown, any> // | REST.ReqResSchemed<unknown, ResA>
-  ResponseOpenApi?: any
-}
-
-export function asRouteDescriptionAny<R extends RouteDescriptorAny>(i: R) {
-  return i as RouteDescriptorAny
-}
-
-export function arrAsRouteDescriptionAny<R extends RouteDescriptorAny>(
-  arr: ReadonlyArray<R>
-) {
-  return arr.map(asRouteDescriptionAny)
-}
-
-export interface RouteDescriptor<
-  M,
-  PathA,
-  CookieA,
-  QueryA,
-  BodyA,
-  HeaderA,
-  ReqA extends PathA & QueryA & BodyA,
-  ResA,
-  METHOD extends REST.Methods.Rest = REST.Methods.Rest
-> {
-  _tag: "Schema"
-  path: `/${string}`
-  method: METHOD
-  handler: RouteRequestHandler<M, PathA, CookieA, QueryA, BodyA, HeaderA, ReqA, ResA, `/${string}`>
-  info?: {
-    tags: ReadonlyArray<string>
-  }
-}
-
-export type RouteDescriptorAny = RouteDescriptor<
-  any,
-  any,
-  any,
-  any,
-  any,
-  any,
-  any,
-  any
->
-
-export function makeRouteDescriptor<
-  M,
-  PathA,
-  CookieA,
-  QueryA,
-  BodyA,
-  HeaderA,
-  ReqA extends PathA & QueryA & BodyA,
-  ResA = void,
-  METHOD extends REST.Methods.Rest = REST.Methods.Rest
->(
-  path: `/${string}`,
-  method: METHOD,
-  handler: RouteRequestHandler<
-    M,
-    PathA,
-    CookieA,
-    QueryA,
-    BodyA,
-    HeaderA,
-    ReqA,
-    ResA,
-    `/${string}`
-  >
-): RouteDescriptor<
-  M,
-  PathA,
-  CookieA,
-  QueryA,
-  BodyA,
-  HeaderA,
-  ReqA,
-  ResA,
-  METHOD
-> {
-  return { path, handler, method, _tag: "Schema" }
-}
-
-// export function makeFromSchema<ResA>(
-//   e: RouteDescriptor<any, any, any, any, any, any, ResA, any>
-// ) {
-//   const jsonSchema_ = OpenApi.for
-//   const jsonSchema = <E, A>(r: REST.ReqRes<A, E, any>) => jsonSchema_(r)
-//   const { Request: Req, Response: Res_, ResponseOpenApi } = e.handler
-//   const r = ResponseOpenApi ?? Res_
-//   const Res = r ? S.extractSchema(r) : S.Void
-//   // TODO EffectOption.fromNullable(Req.Headers).flatMapOpt(jsonSchema)
-//   // TODO: use the path vs body etc serialisation also in the Client.
-//   const makeReqQuerySchema = Effect.sync(() => Option.fromNullable(Req.Query)).flatMap((_) =>
-//     _.match({
-//       onNone: () => Effect.sync(() => Option.none()),
-//       onSome: (_) => jsonSchema(_).map(Option.some)
-//     })
-//   )
-//   const makeReqHeadersSchema = Effect.sync(() => Option.fromNullable(Req.Headers)).flatMap((_) =>
-//     _.match({
-//       onNone: () => Effect.sync(() => Option.none()),
-//       onSome: (_) => jsonSchema(_).map(Option.some)
-//     })
-//   )
-//   const makeReqCookieSchema = Effect.sync(() => Option.fromNullable(Req.Cookie)).flatMap((_) =>
-//     _.match({
-//       onNone: () => Effect.sync(() => Option.none()),
-//       onSome: (_) => jsonSchema(_).map(Option.some)
-//     })
-//   )
-//   const makeReqPathSchema = Effect.sync(() => Option.fromNullable(Req.Path)).flatMap((_) =>
-//     _.match({
-//       onNone: () => Effect.sync(() => Option.none()),
-//       onSome: (_) => jsonSchema(_).map(Option.some)
-//     })
-//   )
-//   const makeReqBodySchema = Effect.sync(() => Option.fromNullable(Req.Body)).flatMap((_) =>
-//     _.match({
-//       onNone: () => Effect.sync(() => Option.none()),
-//       onSome: (_) => jsonSchema(_).map(Option.some)
-//     })
-//   )
-//   // const makeReqSchema = schema(Req)
-
-//   const makeResSchema = jsonSchema_(Res)
-
-//   function makeParameters(inn: ParameterLocation) {
-//     return (a: Option<JSONSchema | SubSchema>) => {
-//       return a
-//         .flatMap((o) => (isObjectSchema(o) ? Option.some(o) : Option.none()))
-//         .map((x) => {
-//           // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-//           return Object.keys(x.properties!).map((p) => {
-//             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-//             const schema = x.properties![p]
-//             const required = Boolean(x.required?.includes(p))
-//             return { name: p, in: inn, required, schema }
-//           })
-//         })
-//         .getOrElse(() => [])
-//     }
-//   }
-
-//   return Effect
-//     .all({
-//       req: jsonSchema(Req.Model),
-//       reqQuery: makeReqQuerySchema,
-//       reqHeaders: makeReqHeadersSchema,
-//       reqBody: makeReqBodySchema,
-//       reqPath: makeReqPathSchema,
-//       reqCookie: makeReqCookieSchema,
-//       res: makeResSchema
-//     })
-//     .map((_) => {
-//       // console.log("$$$ REQ", _.req)
-//       const isEmpty = !e.handler.Response || e.handler.Response === S.Void
-//       return {
-//         path: e.path,
-//         method: e.method.toLowerCase(),
-//         tags: e.info?.tags,
-//         description: _.req?.description,
-//         summary: _.req?.summary,
-//         operationId: _.req?.title,
-//         parameters: [
-//           ...makeParameters("path")(_.reqPath),
-//           ...makeParameters("query")(_.reqQuery),
-//           ...makeParameters("header")(_.reqHeaders),
-//           ...makeParameters("cookie")(_.reqCookie)
-//         ],
-//         requestBody: _
-//           .reqBody
-//           .map((schema) => ({
-//             content: { "application/json": { schema } }
-//           }))
-//           .value,
-//         responses: [
-//           isEmpty
-//             ? new Response(204, { description: "Empty" })
-//             : new Response(200, {
-//               description: "OK",
-//               content: { "application/json": { schema: _.res } }
-//             }),
-//           new Response(400, { description: "ValidationError" })
-//         ]
-//           .concat(
-//             e.path.includes(":") && isEmpty
-//               ? [new Response(404, { description: "NotFoundError" })]
-//               : []
-//           )
-//       }
-//     })
-// }
-
-// class Response {
-//   constructor(
-//     public readonly statusCode: number,
-//     public readonly type: any // string | JSONSchema | SubSchema
-//   ) {}
-// }