@effect-app/infra 0.133.0-next.8 → 0.133.0

package/_src/api/routing/makeRequestHandler.ts

@@ -0,0 +1,278 @@
+/* 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 { 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 { AST } from "@effect-app/schema"
+import type { HttpRequestError } from "../http.js"
+import { HttpBody, HttpRouteContext, HttpServerRequest, HttpServerResponse } from "../http.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 StructFields,
+  CookieA extends StructFields,
+  QueryA extends StructFields,
+  BodyA extends StructFields,
+  HeaderA extends StructFields,
+  ReqA extends PathA & QueryA & BodyA,
+  ResA extends StructFields,
+  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<
+    Exclude<R2, HttpServerRequest> | PR | RequestContextContainer | ContextMapContainer,
+    M,
+    PathA,
+    CookieA,
+    QueryA,
+    BodyA,
+    HeaderA,
+    ReqA,
+    ResA,
+    ResE,
+    PPath,
+    CTX,
+    Context,
+    Config
+  >
+  makeRequestLayer: Layer<R2, MiddlewareE, PR>
+}
+
+export function makeRequestHandler<
+  R,
+  M,
+  PathA extends StructFields,
+  CookieA extends StructFields,
+  QueryA extends StructFields,
+  BodyA extends StructFields,
+  HeaderA extends StructFields,
+  ReqA extends PathA & QueryA & BodyA,
+  ResA extends StructFields,
+  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,
+    res: HttpServerResponse,
+    r2: Effect<R, ValidationError | ResE | MiddlewareE, HttpServerResponse>
+  ) => Effect<RErr | R, never, HttpServerResponse>,
+  middlewareLayer?: Layer<R2, MiddlewareE, PR>
+): Effect<
+  | HttpRouteContext
+  | HttpServerRequest
+  | RequestContextContainer
+  | ContextMapContainer
+  | RErr
+  | Exclude<Exclude<R, EnforceNonEmptyRecord<M>>, PR>
+  | R2,
+  HttpRequestError,
+  HttpServerResponse
+> {
+  const { Request, Response, h: handle } = handler
+
+  const response: REST.ReqRes<any, any> = Response ? Response : Void
+  const resp = response as typeof response & { struct?: Schema<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.encodeSync
+    // ? (i: any) => {
+    //   if (i instanceof (response as any)) return response.encodeSync(i)
+    //   else return response.encodeSync(new (response as any)(i))
+    // }
+    : resp.encodeSync
+  // const encodeResponse = adaptResponse
+  //   ? (req: ReqA) => Encoder.for(adaptResponse(req))
+  //   : () => encoder
+
+  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((
+      { rcx, req }
+    ) => ({
+      params: rcx.params,
+      query: rcx.searchParams,
+      body: req.body,
+      headers: req.headers,
+      cookies: {} // req.cookies
+    }))
+
+  return Effect
+    .gen(function*($) {
+      const req = yield* $(HttpServerRequest)
+      const res = HttpServerResponse
+        .empty()
+        .pipe((_) => req.method === "GET" ? _.setHeader("Cache-Control", "no-store") : _)
+
+      const pars = yield* $(getParams)
+
+      const settings = yield* $(RequestSettings.get)
+
+      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)
+                    .map(encoder)
+                    .map((r) =>
+                      res
+                        .setBody(HttpBody.unsafeJson(r))
+                        .setStatus(r === undefined ? 204 : 200)
+                    )
+                ) as Effect<
+                  Exclude<R, EnforceNonEmptyRecord<M>>,
+                  ValidationError | ResE,
+                  HttpServerResponse
+                >
+
+              // 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<
+                  Exclude<Exclude<R, EnforceNonEmptyRecord<M>>, PR>,
+                  ResE | MiddlewareE | ValidationError,
+                  HttpServerResponse
+                >)
+              return errorHandler(
+                req,
+                res,
+                r2
+              )
+            })
+          )
+          .catchAllCause((cause) =>
+            Effect
+              .sync(() => res.setStatus(500))
+              .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)
+                        .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),
+
+                          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(console.error("Error occurred while reporting error", cause)))
+          )
+          .tap(
+            Effect
+              .logInfo("Finished request")
+              .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(
+          AST.getTitleAnnotation(Request.ast).value ?? "TODO"
+        )
+      })
+    )
+}

package/_src/api/routing/match.ts

@@ -0,0 +1,119 @@
+/* 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 { HttpRouter, type HttpServerRequest, type HttpServerResponse } from "../http.js"
+import type { RequestHandler } from "./base.js"
+import { makeRequestHandler } from "./makeRequestHandler.js"
+import type { Middleware } from "./makeRequestHandler.js"
+
+export const RouteDescriptors = Tag<Ref<RouteDescriptorAny[]>>()
+
+export function match<
+  R,
+  M,
+  PathA extends StructFields,
+  CookieA extends StructFields,
+  QueryA extends StructFields,
+  BodyA extends StructFields,
+  HeaderA extends StructFields,
+  ReqA extends PathA & QueryA & BodyA,
+  ResA extends StructFields,
+  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,
+    res: HttpServerResponse,
+    r2: Effect<R, ValidationError | MiddlewareE | ResE, HttpServerResponse>
+  ) => Effect<RErr | R, never, HttpServerResponse>,
+  middleware?: Middleware<
+    R,
+    M,
+    PathA,
+    CookieA,
+    QueryA,
+    BodyA,
+    HeaderA,
+    ReqA,
+    ResA,
+    ResE,
+    MiddlewareE,
+    PPath,
+    R2,
+    PR,
+    CTX,
+    Context,
+    Config
+  >
+) {
+  let middlewareLayer: Layer<R2, MiddlewareE, PR> | 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
+    )
+    // TODO
+    // rdesc.push(makeRouteDescriptor(
+    //   requestHandler.Request.path,
+    //   requestHandler.Request.method,
+    //   requestHandler
+    // ))
+    return route
+  })
+}

package/_src/api/routing.ts

@@ -0,0 +1,11 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/ban-types */
+
+// codegen:start {preset: barrel, include: routing/*.ts }
+export * from "./routing/base.js"
+export * from "./routing/defaultErrorHandler.js"
+export * from "./routing/makeRequestHandler.js"
+export * from "./routing/match.js"
+// codegen:end
+
+// export * from "@effect-app/infra/api/routing"

package/_src/api/setupRequest.ts

@@ -3,13 +3,6 @@ import { RequestContext } from "../RequestContext.js"
 import { RequestContextContainer } from "../services/RequestContextContainer.js"
 import { ContextMapContainer } from "../services/Store/ContextMapContainer.js"
 
-/**
- * @tsplus fluent effect/io/Effect setupRequestContextFromName
- */
-export function setupRequestContextFromName<R, E, A>(self: Effect<R, E, A>, name: string) {
-  return makeInternalRequestContext(name).flatMap((rc) => setupRequestContext(self, rc))
-}
-
 function makeInternalRequestContext(name: string) {
   return Effect.sync(() => {
     const id = RequestId.make()
@@ -25,40 +18,52 @@ function makeInternalRequestContext(name: string) {
 const withRequestSpan = <R, E, A>(f: Effect<R, E, A>) =>
   RequestContextContainer
     .get
-    .flatMap((ctx) =>
+    .andThen((ctx) =>
       f
-        .withSpan("request", {
-          attributes: {
-            "request.id": ctx.id,
-            "request.name": ctx.name,
-            "request.locale": ctx.locale,
-            "request.namespace": ctx.namespace,
-            ...ctx.userProfile?.sub
-              ? {
-                "request.user.sub": ctx
-                  .userProfile
-                  .sub,
-                "request.user.roles": "roles" in ctx
-                    .userProfile
-                  ? ctx.userProfile.roles
-                  : undefined
-              }
-              : {}
-          }
-        })
+        .withSpan("request", { attributes: ctx.spanAttributes })
         // request context info is picked up directly in the logger for annotations.
         .withLogSpan("request")
     )
 
-function setupContextMap<R, E, A>(self: Effect<R, E, A>) {
-  return (ContextMapContainer.flatMap((_) => _.start)
-    > self)
-}
+const setupContextMap = ContextMapContainer.andThen((_) => _.start).toLayerDiscard
+
+// const RequestContextLiveFromRequestContext = (requestContext: RequestContext) =>
+//   RequestContext.Tag.makeLayer(requestContext)
+// memoization problem
+// const RequestContextLive = RequestContextContainer.get.toLayer(RequestContext.Tag)
+const RequestContextStartLiveFromRequestContext = (requestContext: RequestContext) =>
+  setupContextMap
+    // .provideMerge(RequestContextLiveFromRequestContext(requestContext))
+    .provideMerge(
+      RequestContextContainer
+        .andThen((_) => _.start(requestContext))
+        .toLayerDiscard
+    )
+
+const RequestContextStartLive = (requestContext: RequestContext | string) =>
+  typeof requestContext === "string"
+    ? makeInternalRequestContext(requestContext)
+      .andThen(RequestContextStartLiveFromRequestContext)
+      .unwrapLayer
+    : RequestContextStartLiveFromRequestContext(requestContext)
 
 /**
  * @tsplus fluent effect/io/Effect setupRequestContext
  */
-export function setupRequestContext<R, E, A>(self: Effect<R, E, A>, requestContext: RequestContext) {
-  return RequestContextContainer.flatMap((_) => _.start(requestContext))
-    > withRequestSpan(setupContextMap(self))
+export function setupRequestContext<R, E, A>(self: Effect<R, E, A>, requestContext: RequestContext | string) {
+  return self
+    .pipe(withRequestSpan)
+    .provide(RequestContextStartLive(requestContext))
+}
+
+const UpdateRequestContextLive = (f: (rc: RequestContext) => RequestContext) =>
+  RequestContextContainer.andThen((rcc) => rcc.update(f)).toLayerDiscard
+
+/**
+ * @tsplus fluent effect/io/Effect updateRequestContext
+ */
+export function updateRequestContext<R, E, A>(self: Effect<R, E, A>, f: (rc: RequestContext) => RequestContext) {
+  return self
+    // .provideServiceEffect(RequestContext.Tag, RequestContextContainer.get)
+    .provide(UpdateRequestContextLive(f))
 }

package/_src/errorReporter.ts

@@ -13,12 +13,13 @@ export function reportError(
         return
       }
       yield* $(reportSentry(cause, name, extras))
+      const error = new CauseException(cause, name)
       yield* $(
         Effect
           .logError("Reporting error", cause)
           .annotateLogs(dropUndefined({
             extras,
-            // __cause__: error.toJSON(), // logs too much garbage
+            __cause__: error.toJSON(),
             __error_name__: name
           }))
       )
@@ -50,12 +51,13 @@ export function logError<E>(
         yield* $(Effect.logDebug("Interrupted").annotateLogs(dropUndefined({ extras })))
         return
       }
+      const error = new CauseException(cause, name)
       yield* $(
         Effect
           .logWarning("Logging error", cause)
           .annotateLogs(dropUndefined({
             extras,
-            // __cause__: error.toJSON(), // logs too much garbage
+            __cause__: error.toJSON(),
             __error_name__: name
           }))
       )

package/_src/errors.ts

@@ -1,48 +1,7 @@
 /* eslint-disable @typescript-eslint/ban-types */
 import { makeFiberFailure } from "effect/Runtime"
 
-/** @tsplus type NotFoundError */
-export class NotFoundError<T extends string = string>
-  extends Data.TaggedError("NotFoundError")<{ message: string; type: T; id: string }>
-{
-  constructor(args: { readonly type: T; readonly id: string }) {
-    super({ ...args, message: `Didn't find ${args.type}#${args.id}` })
-  }
-}
-
-/** @tsplus type ValidationError */
-export class ValidationError extends Data.TaggedError("ValidationError")<{ errors: ReadonlyArray<unknown> }> {}
-
-/** @tsplus type NotLoggedInError */
-export class NotLoggedInError extends Data.TaggedError("NotLoggedInError")<{ message?: string | undefined }> {
-  constructor(message?: string) {
-    super({ message })
-  }
-}
-
-/** @tsplus type UnauthorizedError */
-export class UnauthorizedError extends Data.TaggedError("UnauthorizedError")<{ message?: string | undefined }> {
-  constructor(message?: string) {
-    super({ message })
-  }
-}
-
-/**
- * The user carries a valid Userprofile, but there is a problem with the login none the less.
- */
-/** @tsplus type LoginError */
-export class LoginError extends Data.TaggedError("NotLoggeInError")<{ message: string }> {
-  constructor(message: string) {
-    super({ message })
-  }
-}
-
-/** @tsplus type InvalidStateError */
-export class InvalidStateError extends Data.TaggedError("InvalidStateError")<{ message: string }> {
-  constructor(message: string) {
-    super({ message })
-  }
-}
+export * from "@effect-app/prelude/client/errors"
 
 /** @tsplus type CauseException */
 export class CauseException<E> extends Error {
@@ -75,19 +34,3 @@ export class CauseException<E> extends Error {
     return `[${this._tag}] ` + Cause.pretty(this.originalCause)
   }
 }
-
-/** @tsplus type OptimisticConcurrencyException */
-export class OptimisticConcurrencyException extends Data.TaggedError("OptimisticConcurrencyException")<
-  { type: string; id: string; current?: string | undefined; found?: string | undefined; message: string }
-> {
-  constructor(
-    args: {
-      readonly type: string
-      readonly id: string
-      readonly current?: string | undefined
-      readonly found?: string | undefined
-    }
-  ) {
-    super({ ...args, message: `Existing ${args.type} ${args.id} record changed` })
-  }
-}

package/_src/services/QueueMaker/memQueue.ts

@@ -1,6 +1,6 @@
 import { MemQueue } from "@effect-app/infra-adapters/memQueue"
 import { RequestContext } from "@effect-app/infra/RequestContext"
-import type { Schema2 } from "@effect-app/prelude"
+import type { S } from "@effect-app/prelude"
 import { RequestId } from "@effect-app/prelude/ids"
 import { Tracer } from "effect"
 import { RequestContextContainer } from "../RequestContextContainer.js"
@@ -17,8 +17,8 @@ export function makeMemQueue<
 >(
   queueName: string,
   queueDrainName: string,
-  schema: Schema2.Schema<EvtE, Evt>,
-  drainSchema: Schema2.Schema<unknown, DrainEvt>
+  schema: S.Schema<EvtE, Evt>,
+  drainSchema: S.Schema<unknown, DrainEvt>
 ) {
   return Effect.gen(function*($) {
     const mem = yield* $(MemQueue)

package/_src/services/QueueMaker/sbqueue.ts

@@ -9,7 +9,7 @@ import {
 import type {} from "@azure/service-bus"
 import { captureException } from "@effect-app/infra/errorReporter"
 import { RequestContext } from "@effect-app/infra/RequestContext"
-import type { Schema2 } from "@effect-app/prelude"
+import type { S } from "@effect-app/prelude"
 import { RequestId } from "@effect-app/prelude/ids"
 import { struct } from "@effect-app/schema"
 import { Tracer } from "effect"
@@ -27,8 +27,8 @@ export function makeServiceBusQueue<
 >(
   _queueName: string,
   queueDrainName: string,
-  schema: Schema2.Schema<EvtE, Evt>,
-  drainSchema: Schema2.Schema<unknown, DrainEvt>
+  schema: S.Schema<EvtE, Evt>,
+  drainSchema: S.Schema<unknown, DrainEvt>
 ) {
   const wireSchema = struct({
     body: schema,