@effect-app/infra 0.7.0 → 0.8.0

package/_src/lib/api/express/schema/requestHandler.ts

@@ -0,0 +1,360 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/ban-types */
+import * as MO from "@effect-app/schema"
+import type { Methods } from "@effect-app/schema"
+import { Parser } from "@effect-app/schema"
+import type express from "express"
+import { ValidationError } from "../../../../errors.js"
+
+export type _R<T extends Effect<any, any, any>> = [T] extends [
+  Effect<infer R, any, any>
+] ? R
+  : never
+
+export type _E<T extends Effect<any, any, any>> = [T] extends [
+  Effect<any, infer E, any>
+] ? E
+  : never
+
+export type Request<
+  PathA,
+  CookieA,
+  QueryA,
+  BodyA,
+  HeaderA,
+  ReqA extends PathA & QueryA & BodyA
+> = MO.ReqResSchemed<unknown, ReqA> & {
+  method: Methods
+  path: string
+  Cookie?: MO.ReqRes<Record<string, string>, CookieA>
+  Path?: MO.ReqRes<Record<string, string>, PathA>
+  Body?: MO.ReqRes<unknown, BodyA>
+  Query?: MO.ReqRes<Record<string, string>, QueryA>
+  Headers?: MO.ReqRes<Record<string, string>, HeaderA>
+}
+
+export type Request2<
+  Path extends string,
+  Method extends Methods,
+  ReqA
+> = MO.ReqResSchemed<unknown, ReqA> & {
+  method: Method
+  path: Path
+}
+
+export type Encode<A, E> = (a: A) => E
+
+// function getErrorMessage(current: ContextEntry) {
+//   switch (current.type.name) {
+//     case "NonEmptyString":
+//       return "Must not be empty"
+//   }
+//   if (current.type.name?.startsWith("NonEmptyReadonlyArray<")) {
+//     return "Must not be empty"
+//   }
+//   return `Invalid value specified`
+// }
+export function decodeErrors(x: unknown) {
+  return [x]
+}
+
+// const ValidationApplicative = Effect.getValidationApplicative(
+//   makeAssociative<ReadonlyArray<{ type: string; errors: ReturnType<typeof decodeErrors> }>>(
+//     (l, r) => l.concat(r)
+//   )
+// )
+
+// const structValidation = DSL.structF(ValidationApplicative)
+export function parseRequestParams<PathA, CookieA, QueryA, BodyA, HeaderA>(
+  parsers: RequestParsers<PathA, CookieA, QueryA, BodyA, HeaderA>
+) {
+  return ({ body, cookies, headers, params, query }: express.Request) =>
+    Effect.struct({
+      body: parsers
+        .parseBody(body)
+        .exit.flatMap(_ =>
+          _.isFailure() && !_.cause.isFailure()
+            ? (Effect.failCauseSync(() => _.cause) as Effect<never, ValidationError, never>)
+            : Effect(
+              _.isSuccess()
+                ? { _tag: "Success" as const, value: _.value }
+                : { _tag: "Failure", errors: _.cause.failures }
+            )
+        ),
+      cookie: parsers
+        .parseCookie(cookies)
+        .exit.flatMap(_ =>
+          _.isFailure() && !_.cause.isFailure()
+            ? (Effect.failCauseSync(() => _.cause) as Effect<never, ValidationError, never>)
+            : Effect(
+              _.isSuccess()
+                ? { _tag: "Success" as const, value: _.value }
+                : { _tag: "Failure", errors: _.cause.failures }
+            )
+        ),
+      headers: parsers
+        .parseHeaders(headers)
+        .exit.flatMap(_ =>
+          _.isFailure() && !_.cause.isFailure()
+            ? (Effect.failCauseSync(() => _.cause) as Effect<never, ValidationError, never>)
+            : Effect(
+              _.isSuccess()
+                ? { _tag: "Success" as const, value: _.value }
+                : { _tag: "Failure", errors: _.cause.failures }
+            )
+        ),
+      query: parsers
+        .parseQuery(query)
+        .exit.flatMap(_ =>
+          _.isFailure() && !_.cause.isFailure()
+            ? (Effect.failCauseSync(() => _.cause) as Effect<never, ValidationError, never>)
+            : Effect(
+              _.isSuccess()
+                ? { _tag: "Success" as const, value: _.value }
+                : { _tag: "Failure", errors: _.cause.failures }
+            )
+        ),
+      path: parsers
+        .parsePath(params)
+        .exit.flatMap(_ =>
+          _.isFailure() && !_.cause.isFailure()
+            ? (Effect.failCauseSync(() => _.cause) as Effect<never, ValidationError, never>)
+            : Effect(
+              _.isSuccess()
+                ? { _tag: "Success" as const, value: _.value }
+                : { _tag: "Failure", errors: _.cause.failures }
+            )
+        )
+    }).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("path")(path.errors))
+      }
+      if (errors.length) {
+        return Effect.fail(new ValidationError(errors))
+      }
+      return Effect({
+        body: body.value!,
+        cookie: cookie.value!,
+        headers: headers.value!,
+        path: path.value!,
+        query: query.value!
+      })
+    })
+}
+
+// // eslint-disable-next-line @typescript-eslint/no-explicit-any
+// function mapErrors_<E, NE, NER extends Record<string, Effect<any, E, any>>>(
+//   t: NER, // TODO: enforce non empty
+//   mapErrors: (k: keyof NER) => (err: E) => NE
+// ): {
+//   [K in keyof NER]: Effect<_R<NER[K]>, NE, Effect.Success<NER[K]>>
+// } {
+//   return typedKeysOf(t).reduce(
+//     (prev, cur) => {
+//       prev[cur] = t[cur].mapError(mapErrors(cur))
+//       return prev
+//     },
+//     {} as {
+//       [K in keyof NER]: Effect<_R<NER[K]>, NE, Effect.Success<NER[K]>>
+//     }
+//   )
+// }
+
+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(() => {
+          r === undefined
+            ? res.status(204).send()
+            : res.status(200).send(r === null ? JSON.stringify(null) : r)
+        })
+      ))
+}
+
+export interface RequestHandlerOptRes<
+  R,
+  PathA,
+  CookieA,
+  QueryA,
+  BodyA,
+  HeaderA,
+  ReqA extends PathA & QueryA & BodyA,
+  ResA,
+  ResE
+> {
+  adaptResponse?: any
+  h: (i: PathA & QueryA & BodyA & {}) => Effect<R, ResE, ResA>
+  Request: Request<PathA, CookieA, QueryA, BodyA, HeaderA, ReqA>
+  Response?: MO.ReqRes<unknown, ResA> | MO.ReqResSchemed<unknown, ResA>
+}
+
+export interface RequestHandler<
+  R,
+  PathA,
+  CookieA,
+  QueryA,
+  BodyA,
+  HeaderA,
+  ReqA extends PathA & QueryA & BodyA,
+  ResA,
+  ResE
+> {
+  adaptResponse?: any
+  h: (i: PathA & QueryA & BodyA & {}) => Effect<R, ResE, ResA>
+  Request: Request<PathA, CookieA, QueryA, BodyA, HeaderA, ReqA>
+  Response: MO.ReqRes<unknown, ResA> | MO.ReqResSchemed<unknown, ResA>
+  ResponseOpenApi?: any
+}
+
+export interface RequestHandler2<
+  R,
+  Path extends string,
+  Method extends Methods,
+  ReqA,
+  ResA,
+  ResE
+> {
+  h: (i: ReqA) => Effect<R, ResE, ResA>
+  Request: Request2<Path, Method, ReqA>
+  Response: MO.ReqRes<unknown, ResA> | MO.ReqResSchemed<unknown, ResA>
+}
+
+export type MiddlewareHandler<ResE, R2 = never, PR = never> = (
+  req: express.Request,
+  res: express.Response
+) => Layer<R2, ResE, PR>
+
+export type Middleware<
+  R,
+  PathA,
+  CookieA,
+  QueryA,
+  BodyA,
+  HeaderA,
+  ReqA extends PathA & QueryA & BodyA,
+  ResA,
+  ResE,
+  R2 = never,
+  PR = never
+> = (
+  handler: RequestHandler<R, PathA, CookieA, QueryA, BodyA, HeaderA, ReqA, ResA, ResE>
+) => {
+  handler: typeof handler
+  handle: MiddlewareHandler<ResE, R2, PR>
+}
+
+export type Middleware2<R, ReqA, ResA, R2 = never, PR = never> = Middleware<
+  R,
+  any,
+  any,
+  any,
+  any,
+  any,
+  ReqA,
+  ResA,
+  any,
+  R2,
+  PR
+>
+
+export function makeRequestParsers<
+  R,
+  PathA,
+  CookieA,
+  QueryA,
+  BodyA,
+  HeaderA,
+  ReqA extends PathA & QueryA & BodyA,
+  ResA,
+  Errors
+>(
+  Request: RequestHandler<
+    R,
+    PathA,
+    CookieA,
+    QueryA,
+    BodyA,
+    HeaderA,
+    ReqA,
+    ResA,
+    Errors
+  >["Request"]
+): RequestParsers<PathA, CookieA, QueryA, BodyA, HeaderA> {
+  const ph = Effect(
+    Opt.fromNullable(Request.Headers)
+      .map(s => s)
+      .map(Parser.for)
+      .map(MO.condemn)
+  )
+  const parseHeaders = (u: unknown) => ph.flatMapOpt(d => d(u))
+
+  const pq = Effect(
+    Opt.fromNullable(Request.Query)
+      .map(s => s)
+      .map(Parser.for)
+      .map(MO.condemn)
+  )
+  const parseQuery = (u: unknown) => pq.flatMapOpt(d => d(u))
+
+  const pb = Effect(
+    Opt.fromNullable(Request.Body)
+      .map(s => s)
+      .map(Parser.for)
+      .map(MO.condemn)
+  )
+  const parseBody = (u: unknown) => pb.flatMapOpt(d => d(u))
+
+  const pp = Effect(
+    Opt.fromNullable(Request.Path)
+      .map(s => s)
+      .map(Parser.for)
+      .map(MO.condemn)
+  )
+  const parsePath = (u: unknown) => pp.flatMapOpt(d => d(u))
+
+  const pc = Effect(
+    Opt.fromNullable(Request.Cookie)
+      .map(s => s)
+      .map(Parser.for)
+      .map(MO.condemn)
+  )
+  const parseCookie = (u: unknown) => pc.flatMapOpt(d => d(u))
+
+  return {
+    parseBody,
+    parseCookie,
+    parseHeaders,
+    parsePath,
+    parseQuery
+  }
+}
+
+type Decode<A> = (u: unknown) => Effect<never, unknown, A>
+
+export interface RequestParsers<PathA, CookieA, QueryA, BodyA, HeaderA> {
+  parseHeaders: Decode<Opt<HeaderA>>
+  parseQuery: Decode<Opt<QueryA>>
+  parseBody: Decode<Opt<BodyA>>
+  parsePath: Decode<Opt<PathA>>
+  parseCookie: Decode<Opt<CookieA>>
+}

package/_src/lib/api/express/schema/routing.ts

@@ -0,0 +1,202 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import * as MO from "@effect-app/schema"
+import type { Methods } from "@effect-app/schema"
+
+import type { JSONSchema, ParameterLocation, SubSchema } from "@effect-app/infra-adapters/Openapi/atlas-plutus"
+import { isObjectSchema } from "@effect-app/infra-adapters/Openapi/atlas-plutus"
+import * as OpenApi from "@effect-app/infra-adapters/Openapi/index"
+import type { RequestHandler, RequestHandlerOptRes } from "./requestHandler.js"
+
+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<
+  R,
+  PathA,
+  CookieA,
+  QueryA,
+  BodyA,
+  HeaderA,
+  ReqA extends PathA & QueryA & BodyA,
+  ResA,
+  Errors,
+  METHOD extends Methods = Methods
+> {
+  path: string
+  method: METHOD
+  handler: RequestHandler<R, PathA, CookieA, QueryA, BodyA, HeaderA, ReqA, ResA, Errors>
+  info?: {
+    tags: ReadonlyArray<string>
+  }
+}
+
+export type RouteDescriptorAny = RouteDescriptor<
+  any,
+  any,
+  any,
+  any,
+  any,
+  any,
+  any,
+  any,
+  any
+>
+
+export function makeRouteDescriptor<
+  R,
+  PathA,
+  CookieA,
+  QueryA,
+  BodyA,
+  HeaderA,
+  ReqA extends PathA & QueryA & BodyA,
+  ResA = void,
+  Errors = any,
+  METHOD extends Methods = Methods
+>(
+  path: string,
+  method: METHOD,
+  handler: RequestHandlerOptRes<
+    R,
+    PathA,
+    CookieA,
+    QueryA,
+    BodyA,
+    HeaderA,
+    ReqA,
+    ResA,
+    Errors
+  >
+) {
+  return { path, method, handler, _tag: "Schema" } as RouteDescriptor<
+    R,
+    PathA,
+    CookieA,
+    QueryA,
+    BodyA,
+    HeaderA,
+    ReqA,
+    ResA,
+    Errors,
+    METHOD
+  >
+}
+
+export function makeFromSchema<ResA>(
+  e: RouteDescriptor<any, any, any, any, any, any, ResA, any, any>
+) {
+  const jsonSchema_ = OpenApi.for
+  const jsonSchema = <E, A>(r: MO.ReqRes<E, A>) => jsonSchema_(r)
+  const { Request: Req, Response: Res_, ResponseOpenApi } = e.handler
+  const r = ResponseOpenApi ?? Res_
+  const Res = r ? MO.extractSchema(r) : MO.Void
+  // TODO EffectOpt.fromNullable(Req.Headers).flatMapOpt(jsonSchema)
+  // TODO: use the path vs body etc serialisation also in the Client.
+  const makeReqQuerySchema = Effect(Opt.fromNullable(Req.Query)).flatMap(_ =>
+    _.match(
+      () => Effect(Opt.none),
+      _ => jsonSchema(_).map(Opt.some)
+    )
+  )
+  const makeReqHeadersSchema = Effect(Opt.fromNullable(Req.Headers)).flatMap(_ =>
+    _.match(
+      () => Effect(Opt.none),
+      _ => jsonSchema(_).map(Opt.some)
+    )
+  )
+  const makeReqCookieSchema = Effect(Opt.fromNullable(Req.Cookie)).flatMap(_ =>
+    _.match(
+      () => Effect(Opt.none),
+      _ => jsonSchema(_).map(Opt.some)
+    )
+  )
+  const makeReqPathSchema = Effect(Opt.fromNullable(Req.Path)).flatMap(_ =>
+    _.match(
+      () => Effect(Opt.none),
+      _ => jsonSchema(_).map(Opt.some)
+    )
+  )
+  const makeReqBodySchema = Effect(Opt.fromNullable(Req.Body)).flatMap(_ =>
+    _.match(
+      () => Effect(Opt.none),
+      _ => jsonSchema(_).map(Opt.some)
+    )
+  )
+  // const makeReqSchema = schema(Req)
+
+  const makeResSchema = jsonSchema_(Res)
+
+  function makeParameters(inn: ParameterLocation) {
+    return (a: Opt<JSONSchema | SubSchema>) => {
+      return a
+        .flatMap(o => (isObjectSchema(o) ? Opt(o) : Opt.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.struct({
+    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 === MO.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
+  ) {}
+}

package/_src/lib/api/routing.ts

@@ -1,24 +1,19 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
+import * as Ex from "@effect-app/infra-adapters/express"
 import type { _E, _R } from "@effect-app/prelude/_ext/Prelude.ext"
 import type { GetRequest, GetResponse } from "@effect-app/prelude/schema"
 import { extractSchema, SchemaNamed } from "@effect-app/prelude/schema"
 import * as MO from "@effect-app/prelude/schema"
 import { pretty } from "@effect-app/prelude/utils"
-import * as Ex from "@effect-app/infra-adapters/express/index"
-import type {
-  Encode,
-  RequestHandler,
-  RequestHandlerOptRes,
-  RequestParsers
-} from "@effect-app/infra-adapters/express/schema/requestHandler"
-import { parseRequestParams } from "@effect-app/infra-adapters/express/schema/requestHandler"
-import type { RouteDescriptorAny } from "@effect-app/infra-adapters/express/schema/routing"
-import { makeRouteDescriptor } from "@effect-app/infra-adapters/express/schema/routing"
 import type express from "express"
 import type { ValidationError } from "../../errors.js"
 import { RequestContext, RequestId } from "../../lib/RequestContext.js"
 import type { SupportedErrors } from "./defaultErrorHandler.js"
 import { defaultBasicErrorHandler } from "./defaultErrorHandler.js"
+import type { Encode, RequestHandler, RequestHandlerOptRes, RequestParsers } from "./express/schema/requestHandler.js"
+import { parseRequestParams } from "./express/schema/requestHandler.js"
+import type { RouteDescriptorAny } from "./express/schema/routing.js"
+import { makeRouteDescriptor } from "./express/schema/routing.js"
 import { reportRequestError } from "./reportError.js"
 import { snipString, snipValue } from "./util.js"
 

package/_src/lib/api/writeDocs.ts

@@ -1,9 +1,8 @@
-import { makeOpenApiSpecs } from "@effect-app/infra-adapters/express/makeOpenApiSpecs"
-import type { RouteDescriptorAny } from "@effect-app/infra-adapters/express/schema/routing"
-import * as Plutus from "@effect-app/infra-adapters/Openapi/atlas-plutus"
-import { writeTextFile } from "@effect-app/infra-adapters/simpledb/fileutil"
-
 import { typedValuesOf } from "@effect-app/core/utils"
+import * as Plutus from "@effect-app/infra-adapters/Openapi/atlas-plutus"
+import { writeTextFile } from "../../services/simpledb/fileutil.js"
+import { makeOpenApiSpecs } from "./express/makeOpenApiSpecs.js"
+import type { RouteDescriptorAny } from "./express/schema/routing.js"
 
 export function writeOpenapiDocs(rdescs: Record<string, Record<string, RouteDescriptorAny>>) {
   return makeOpenApiSpecs(

package/_src/services/Store/Disk.ts

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import * as fu from "@effect-app/infra-adapters/simpledb/fileutil"
+import * as fu from "../simpledb/fileutil.js"
 
 import fs from "fs"