@effect-app/infra 0.7.0 → 0.8.1

package/_src/api/express/routing.ts.bak

@@ -0,0 +1,460 @@
+/* eslint-disable @typescript-eslint/ban-types */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import * as MO from "@effect-app/schema"
+import { Encoder, extractSchema } from "@effect-app/schema"
+import type express from "express"
+
+import * as Ex from "@effect-app/infra-adapters/express"
+import type { NotFoundError, NotLoggedInError, UnauthorizedError, ValidationError } from "../../../errors.js"
+import type {
+  Encode,
+  Middleware,
+  MiddlewareHandler,
+  RequestHandler,
+  RequestHandlerOptRes,
+  RequestParsers
+} from "./schema/requestHandler.js"
+import { makeRequestParsers, parseRequestParams, respondSuccess } from "./schema/requestHandler.js"
+import { makeRouteDescriptor } from "./schema/routing.js"
+
+/*
+An app should take ownership over these
+*/
+export type SupportedErrors =
+  | ValidationError
+  | NotFoundError
+  | NotLoggedInError
+  | UnauthorizedError
+
+export function match<
+  R,
+  PathA,
+  CookieA,
+  QueryA,
+  BodyA,
+  HeaderA,
+  ReqA extends {} & PathA & QueryA & BodyA,
+  ResA,
+  R2 = never,
+  PR = never
+>(
+  r: RequestHandler<
+    R,
+    PathA,
+    CookieA,
+    QueryA,
+    BodyA,
+    HeaderA,
+    ReqA,
+    ResA,
+    SupportedErrors
+  >,
+  mw?: Middleware<
+    R,
+    PathA,
+    CookieA,
+    QueryA,
+    BodyA,
+    HeaderA,
+    ReqA,
+    ResA,
+    SupportedErrors,
+    R2,
+    PR
+  >
+) {
+  let h: MiddlewareHandler<SupportedErrors, R2, PR> | undefined = undefined
+  if (mw) {
+    const { handle, handler } = mw(r)
+    r = handler
+    h = handle
+  }
+  return Ex.match(r.Request.method.toLowerCase() as any)(
+    r.Request.path.split("?")[0],
+    makeRequestHandler<R, PathA, CookieA, QueryA, BodyA, HeaderA, ReqA, ResA, R2, PR>(
+      r,
+      h
+    )
+  ).zipRight(
+    Effect(() => makeRouteDescriptor(r.Request.path, r.Request.method, r))
+  )
+}
+
+export function makeRequestHandler<
+  R,
+  PathA,
+  CookieA,
+  QueryA,
+  BodyA,
+  HeaderA,
+  ReqA extends {} & PathA & QueryA & BodyA,
+  ResA = void,
+  R2 = never,
+  PR = never
+>(
+  handle: RequestHandlerOptRes<
+    R | PR,
+    PathA,
+    CookieA,
+    QueryA,
+    BodyA,
+    HeaderA,
+    ReqA,
+    ResA,
+    SupportedErrors
+  >,
+  h?: (req: express.Request, res: express.Response) => Layer<R2, SupportedErrors, PR>
+) {
+  const { Request, Response } = handle
+  const res = Response ? extractSchema(Response as any) : MO.Void
+  const encodeResponse = handle.adaptResponse
+    ? (req: ReqA) => Encoder.for(handle.adaptResponse(req))
+    : () => Encoder.for(res)
+
+  return handleRequest<
+    R,
+    PathA,
+    CookieA,
+    QueryA,
+    BodyA,
+    HeaderA,
+    ResA,
+    never,
+    ReqA,
+    R2,
+    PR
+  >(makeRequestParsers(Request), encodeResponse as any, handle.h, h)
+}
+export function handleRequest<
+  R,
+  PathA,
+  CookieA,
+  QueryA,
+  BodyA,
+  HeaderA,
+  ResA,
+  ResE,
+  ReqA extends {} & PathA & BodyA & QueryA,
+  R2 = never,
+  PR = never
+>(
+  requestParsers: RequestParsers<PathA, CookieA, QueryA, BodyA, HeaderA>,
+  encodeResponse: (r: ReqA) => Encode<ResA, ResE>,
+  handle: (r: ReqA) => Effect<R | PR, SupportedErrors, ResA>,
+  h?: (req: express.Request, res: express.Response) => Layer<R2, SupportedErrors, PR>
+) {
+  const parseRequest = parseRequestParams(requestParsers)
+  const respond = respondSuccess(encodeResponse)
+  return (req: express.Request, res: express.Response) =>
+    parseRequest(req)
+      .map(({ body, path, query }) => {
+        const hn = {
+          ...body.value,
+          ...query.value,
+          ...path.value
+        } as ReqA
+        return hn
+      })
+      .flatMap(inp => {
+        const hn = handle(inp)
+        const r = h ? hn.provideSomeLayer(h(req, res)) : hn
+        return (
+          r as never as Effect<Exclude<R | R2, PR>, SupportedErrors, ResA>
+        ).flatMap(outp => respond(inp, res)(outp))
+      })
+      .catchTag("ValidationError", err =>
+        Effect(() => {
+          res.status(400).send(err.errors)
+        }))
+      .catchTag("NotFoundError", err =>
+        Effect(() => {
+          res.status(404).send(err)
+        }))
+      .catchTag("NotLoggedInError", err =>
+        Effect(() => {
+          res.status(401).send(err)
+        }))
+      .catchTag("UnauthorizedError", err =>
+        Effect(() => {
+          res.status(403).send(err)
+        }))
+      // final catch all; expecting never so that unhandled known errors will show up
+      .catchAll((err: never) =>
+        Effect(() =>
+          console.error(
+            "Program error, compiler probably silenced, got an unsupported Error in Error Channel of Effect",
+            err
+          )
+        ).flatMap(Effect.die)
+      )
+  // .tapCause(() => Effect(() => res.status(500).send()))
+}
+
+// Additional convenience helpers
+
+export function get<
+  R,
+  PathA,
+  CookieA,
+  QueryA,
+  BodyA,
+  HeaderA,
+  ReqA extends {} & PathA & QueryA & BodyA,
+  ResA,
+  R2 = never,
+  PR = never
+>(
+  path: string,
+  r: RequestHandler<
+    R,
+    PathA,
+    CookieA,
+    QueryA,
+    BodyA,
+    HeaderA,
+    ReqA,
+    ResA,
+    SupportedErrors
+  >,
+  mw?: Middleware<
+    R,
+    PathA,
+    CookieA,
+    QueryA,
+    BodyA,
+    HeaderA,
+    ReqA,
+    ResA,
+    SupportedErrors,
+    R2,
+    PR
+  >
+) {
+  let h: MiddlewareHandler<SupportedErrors, R2, PR> | undefined = undefined
+  if (mw) {
+    const { handle, handler } = mw(r)
+    r = handler
+    h = handle
+  }
+  return Ex.get(
+    path,
+    makeRequestHandler<R, PathA, CookieA, QueryA, BodyA, HeaderA, ReqA, ResA, R2, PR>(
+      r,
+      h
+    )
+  ).zipRight(Effect(() => makeRouteDescriptor(path, "GET", r)))
+}
+
+export function post<
+  R,
+  PathA,
+  CookieA,
+  QueryA,
+  BodyA,
+  HeaderA,
+  ReqA extends {} & PathA & QueryA & BodyA,
+  ResA = void,
+  R2 = never,
+  PR = never
+>(
+  path: string,
+  r: RequestHandler<
+    R,
+    PathA,
+    CookieA,
+    QueryA,
+    BodyA,
+    HeaderA,
+    ReqA,
+    ResA,
+    SupportedErrors
+  >,
+  mw?: Middleware<
+    R,
+    PathA,
+    CookieA,
+    QueryA,
+    BodyA,
+    HeaderA,
+    ReqA,
+    ResA,
+    SupportedErrors,
+    R2,
+    PR
+  >
+) {
+  let h: MiddlewareHandler<SupportedErrors, R2, PR> | undefined = undefined
+  if (mw) {
+    const { handle, handler } = mw(r)
+    r = handler
+    h = handle
+  }
+  return Ex.post(
+    path,
+    makeRequestHandler<R, PathA, CookieA, QueryA, BodyA, HeaderA, ReqA, ResA, R2, PR>(
+      r,
+      h
+    )
+  ).zipRight(Effect(() => makeRouteDescriptor(path, "POST", r)))
+}
+
+export function put<
+  R,
+  PathA,
+  CookieA,
+  QueryA,
+  BodyA,
+  HeaderA,
+  ReqA extends {} & PathA & QueryA & BodyA,
+  ResA = void,
+  R2 = never,
+  PR = never
+>(
+  path: string,
+  r: RequestHandler<
+    R,
+    PathA,
+    CookieA,
+    QueryA,
+    BodyA,
+    HeaderA,
+    ReqA,
+    ResA,
+    SupportedErrors
+  >,
+  mw?: Middleware<
+    R,
+    PathA,
+    CookieA,
+    QueryA,
+    BodyA,
+    HeaderA,
+    ReqA,
+    ResA,
+    SupportedErrors,
+    R2,
+    PR
+  >
+) {
+  let h: MiddlewareHandler<SupportedErrors, R2, PR> | undefined = undefined
+  if (mw) {
+    const { handle, handler } = mw(r)
+    r = handler
+    h = handle
+  }
+  return Ex.put(
+    path,
+    makeRequestHandler<R, PathA, CookieA, QueryA, BodyA, HeaderA, ReqA, ResA, R2, PR>(
+      r,
+      h
+    )
+  ).zipRight(Effect(() => makeRouteDescriptor(path, "PUT", r)))
+}
+
+export function patch<
+  R,
+  PathA,
+  CookieA,
+  QueryA,
+  BodyA,
+  HeaderA,
+  ReqA extends {} & PathA & QueryA & BodyA,
+  ResA = void,
+  R2 = never,
+  PR = never
+>(
+  path: string,
+  r: RequestHandler<
+    R,
+    PathA,
+    CookieA,
+    QueryA,
+    BodyA,
+    HeaderA,
+    ReqA,
+    ResA,
+    SupportedErrors
+  >,
+  mw?: Middleware<
+    R,
+    PathA,
+    CookieA,
+    QueryA,
+    BodyA,
+    HeaderA,
+    ReqA,
+    ResA,
+    SupportedErrors,
+    R2,
+    PR
+  >
+) {
+  let h: MiddlewareHandler<SupportedErrors, R2, PR> | undefined = undefined
+  if (mw) {
+    const { handle, handler } = mw(r)
+    r = handler
+    h = handle
+  }
+  return Ex.patch(
+    path,
+    makeRequestHandler<R, PathA, CookieA, QueryA, BodyA, HeaderA, ReqA, ResA, R2, PR>(
+      r,
+      h
+    )
+  ).zipRight(Effect(() => makeRouteDescriptor(path, "PATCH", r)))
+}
+
+function del<
+  R,
+  PathA,
+  CookieA,
+  QueryA,
+  BodyA,
+  HeaderA,
+  ReqA extends {} & PathA & QueryA & BodyA,
+  ResA = void,
+  R2 = never,
+  PR = never
+>(
+  path: string,
+  r: RequestHandler<
+    R,
+    PathA,
+    CookieA,
+    QueryA,
+    BodyA,
+    HeaderA,
+    ReqA,
+    ResA,
+    SupportedErrors
+  >,
+  mw?: Middleware<
+    R,
+    PathA,
+    CookieA,
+    QueryA,
+    BodyA,
+    HeaderA,
+    ReqA,
+    ResA,
+    SupportedErrors,
+    R2,
+    PR
+  >
+) {
+  let h: MiddlewareHandler<SupportedErrors, R2, PR> | undefined = undefined
+  if (mw) {
+    const { handle, handler } = mw(r)
+    r = handler
+    h = handle
+  }
+  return Ex.delete(
+    path,
+    makeRequestHandler<R, PathA, CookieA, QueryA, BodyA, HeaderA, ReqA, ResA, R2, PR>(
+      r,
+      h
+    )
+  ).zipRight(Effect(() => makeRouteDescriptor(path, "DELETE", r)))
+}
+
+export { del as delete }

package/_src/api/express/schema/jwt.ts

@@ -0,0 +1,38 @@
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/ban-types */
+import { pipe } from "@effect-app/core/Function"
+import * as MO from "@effect-app/schema"
+import { These as Th } from "@effect-app/schema"
+import jwt_decode from "jwt-decode"
+
+export const jwtIdentifier = MO.makeAnnotation<{}>()
+
+export const jwtFromString: MO.Schema<string, unknown, unknown, string, {}> = pipe(
+  // MO.identity((u): u is string => typeof u === "string"),
+  MO.identity((u): u is string => {
+    throw new Error("Cannot id JWT: " + u)
+  }),
+  MO.constructor(n => Th.succeed(n)),
+  //   MO.arbitrary((_) => {
+  //     throw new Error("Cannot arb JWT")
+  //   }), // TODO
+  //   MO.encoder((_) => {
+  //     throw new Error("can't encode")
+  //   }),
+  MO.parser((p: any) => {
+    try {
+      return Th.succeed(
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-expect-error
+        jwt_decode(p)
+      )
+    } catch (err) {
+      return Th.fail(MO.leafE(MO.parseStringE(p))) // "not a JWT: " + err as anyw
+    }
+  }),
+  MO.mapApi(() => ({})),
+  MO.annotate(jwtIdentifier, {})
+)
+
+export const jwt = MO.string[">>>"](jwtFromString)