effect-app 1.20.0 → 1.21.0

package/src/client/clientFor2.ts

@@ -1,339 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unsafe-argument */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-
-import { Effect, flow, HashMap, Layer, Option, Predicate, Struct } from "@effect-app/core"
-import { RpcResolver } from "@effect/rpc"
-import { HttpRpcResolver } from "@effect/rpc-http"
-import type { RpcRouter } from "@effect/rpc/RpcRouter"
-import type * as Serializable from "@effect/schema/Serializable"
-import { S } from "effect-app"
-import type { FetchResponse } from "effect-app/client"
-import { ApiConfig, makePathWithBody, makePathWithQuery } from "effect-app/client"
-import { HttpClient, HttpClientRequest } from "effect-app/http"
-import type { Schema } from "effect-app/schema"
-import { typedKeysOf } from "effect-app/utils"
-import type * as Request from "effect/Request"
-import { Path } from "path-parser"
-
-type Requests = Record<string, any>
-
-const apiClient = Effect.gen(function*() {
-  const client = yield* HttpClient.HttpClient
-  const config = yield* ApiConfig.Tag
-  return client.pipe(
-    HttpClient.mapRequest(HttpClientRequest.prependUrl(config.apiUrl + "/rpc")),
-    HttpClient.mapRequest(
-      HttpClientRequest.setHeaders(config.headers.pipe(Option.getOrElse(() => HashMap.empty())))
-    )
-  )
-})
-
-export type Client<M extends Requests> =
-  & RequestHandlers<
-    ApiConfig | HttpClient.HttpClient.Service,
-    never, // SupportedErrors | FetchError | ResError,
-    M
-  >
-  & RequestHandlersE<
-    ApiConfig | HttpClient.HttpClient.Service,
-    never, // SupportedErrors | FetchError | ResError,
-    M
-  >
-
-export function clientFor2(layers: Layer.Layer<never, never, never>) {
-  const cache = new Map<any, Client<any>>()
-
-  return <M extends Requests>(
-    models: M
-  ): Client<Omit<M, "meta">> => {
-    const found = cache.get(models)
-    if (found) {
-      return found
-    }
-    const m = clientFor_(models, layers)
-    cache.set(models, m)
-    return m
-  }
-}
-
-type Req = S.Schema.All & {
-  new(...args: any[]): any
-  _tag: string
-  fields: S.Struct.Fields
-  success: S.Schema.Any
-  failure: S.Schema.Any
-  config?: Record<string, any>
-}
-
-function clientFor_<M extends Requests>(models: M, layers = Layer.empty) {
-  type Filtered = {
-    [K in keyof Requests as Requests[K] extends Req ? K : never]: Requests[K] extends Req ? Requests[K] : never
-  }
-  const filtered = typedKeysOf(models).reduce((acc, cur) => {
-    if (
-      Predicate.isObject(models[cur])
-      && (models[cur].success)
-    ) {
-      acc[cur as keyof Filtered] = models[cur]
-    }
-    return acc
-  }, {} as Record<keyof Filtered, Req>)
-
-  const meta = (models as any).meta as { moduleName: string }
-  if (!meta) throw new Error("No meta defined in Resource!")
-
-  const resolver = flow(
-    HttpRpcResolver.make<RpcRouter<any, any>>,
-    (_) => RpcResolver.toClient(_ as any)
-  )
-
-  const baseClient = apiClient.pipe(
-    Effect.andThen(HttpClient.mapRequest(HttpClientRequest.appendUrl("/" + meta.moduleName)))
-  )
-
-  return (typedKeysOf(filtered)
-    .reduce((prev, cur) => {
-      const h = filtered[cur]!
-
-      const Request = h
-      const Response = h.success
-
-      const encodeRequest = S.encodeSync(
-        Request as unknown as S.Schema<any, any>
-      )
-
-      const requestName = `${meta.moduleName}.${cur as string}`
-        .replaceAll(".js", "")
-
-      const requestMeta = {
-        method: "POST", // TODO
-        Request,
-        Response,
-        mapPath: requestName,
-        name: requestName
-      }
-
-      const client = baseClient.pipe(
-        Effect.andThen(HttpClient.mapRequest(HttpClientRequest.appendUrlParam("action", cur as string))),
-        Effect.andThen(resolver)
-      )
-
-      const fields = Struct.omit(Request.fields, "_tag")
-      const p = requestName
-      const path = new Path(p) // TODO
-      // @ts-expect-error doc
-      prev[cur] = requestMeta.method === "GET"
-        ? Object.keys(fields).length === 0
-          ? {
-            handler: client
-              .pipe(
-                Effect.andThen((cl) => cl(new Request())),
-                Effect.map((_) => ({ body: _, status: 200, headers: {} })), // TODO
-                Effect
-                  .withSpan("client.request " + requestName, {
-                    captureStackTrace: false,
-                    attributes: { "request.name": requestName }
-                  }),
-                Effect.provide(layers)
-              ),
-            ...requestMeta
-          }
-          : {
-            handler: (req: any) =>
-              client
-                .pipe(
-                  Effect.andThen((cl) => cl(new Request(req))),
-                  Effect.map((_) => ({ body: _, status: 200, headers: {} })), // TODO
-                  Effect
-                    .withSpan("client.request " + requestName, {
-                      captureStackTrace: false,
-                      attributes: { "request.name": requestName }
-                    }),
-                  Effect.provide(layers)
-                ),
-            ...requestMeta,
-            mapPath: (req: any) => req ? makePathWithQuery(path, encodeRequest(req)) : p
-          }
-        : Object.keys(fields).length === 0
-        ? {
-          handler: client
-            .pipe(
-              Effect.andThen((cl) => cl(new Request())),
-              Effect.map((_) => ({ body: _, status: 200, headers: {} })), // TODO
-              Effect.withSpan("client.request " + requestName, {
-                captureStackTrace: false,
-                attributes: { "request.name": requestName }
-              }),
-              Effect.provide(layers)
-            ),
-          ...requestMeta
-        }
-        : {
-          handler: (req: any) =>
-            client
-              .pipe(
-                Effect.andThen((cl) => cl(new Request(req))),
-                Effect.map((_) => ({ body: _, status: 200, headers: {} })), // TODO
-                Effect.withSpan("client.request " + requestName, {
-                  captureStackTrace: false,
-                  attributes: { "request.name": requestName }
-                }),
-                Effect.provide(layers)
-              ),
-
-          ...requestMeta,
-          mapPath: (req: any) =>
-            req
-              ? requestMeta.method === "DELETE"
-                ? makePathWithQuery(path, encodeRequest(req))
-                : makePathWithBody(path, encodeRequest(req))
-              : p
-        }
-
-      // generate handler
-
-      // @ts-expect-error doc
-      prev[`${cur}E`] = requestMeta.method === "GET"
-        ? Object.keys(fields).length === 0
-          ? {
-            handler: client
-              .pipe(
-                Effect.andThen((cl) => cl(new Request())),
-                Effect.flatMap((res) => S.encode(Response)(res)), // TODO
-                Effect.map((_) => ({ body: _, status: 200, headers: {} })), // TODO,
-                Effect
-                  .withSpan("client.request " + requestName, {
-                    captureStackTrace: false,
-                    attributes: { "request.name": requestName }
-                  }),
-                Effect.provide(layers)
-              ),
-            ...requestMeta
-          }
-          : {
-            handler: (req: any) =>
-              client
-                .pipe(
-                  Effect.andThen((cl) => cl(new Request(req))),
-                  Effect.flatMap((res) => S.encode(Response)(res)), // TODO
-                  Effect.map((_) => ({ body: _, status: 200, headers: {} })), // TODO,
-                  Effect
-                    .withSpan("client.request " + requestName, {
-                      captureStackTrace: false,
-                      attributes: { "request.name": requestName }
-                    }),
-                  Effect.provide(layers)
-                ),
-
-            ...requestMeta,
-            mapPath: (req: any) => req ? makePathWithQuery(path, encodeRequest(req)) : p
-          }
-        : Object.keys(fields).length === 0
-        ? {
-          handler: client
-            .pipe(
-              Effect.andThen((cl) => cl(new Request())),
-              Effect.flatMap((res) => S.encode(Response)(res)), // TODO
-              Effect.map((_) => ({ body: _, status: 200, headers: {} })), // TODO,
-              Effect.withSpan("client.request " + requestName, {
-                captureStackTrace: false,
-                attributes: { "request.name": requestName }
-              }),
-              Effect.provide(layers)
-            ),
-          ...requestMeta
-        }
-        : {
-          handler: (req: any) =>
-            client
-              .pipe(
-                Effect.andThen((cl) => cl(new Request(req))),
-                Effect.flatMap((res) => S.encode(Response)(res)), // TODO
-                Effect.map((_) => ({ body: _, status: 200, headers: {} })), // TODO,
-                Effect.withSpan("client.request " + requestName, {
-                  captureStackTrace: false,
-                  attributes: { "request.name": requestName }
-                }),
-                Effect.provide(layers)
-              ),
-
-          ...requestMeta,
-          mapPath: (req: any) =>
-            req
-              ? requestMeta.method === "DELETE"
-                ? makePathWithQuery(path, encodeRequest(req))
-                : makePathWithBody(path, encodeRequest(req))
-              : p
-        }
-      // generate handler
-
-      return prev
-    }, {} as Client<M>))
-}
-
-export type ExtractResponse<T> = T extends Schema<any, any, any> ? Schema.Type<T>
-  : T extends unknown ? void
-  : never
-
-export type ExtractEResponse<T> = T extends Schema<any, any, any> ? Schema.Encoded<T>
-  : T extends unknown ? void
-  : never
-
-type IsEmpty<T> = keyof T extends never ? true
-  : false
-
-type Cruft = "_tag" | Request.RequestTypeId | typeof Serializable.symbol | typeof Serializable.symbolResult
-
-// TODO: refactor to new Request pattern, then filter out non-requests similar to the runtime changes in clientFor, and matchFor (boilerplate)
-type RequestHandlers<R, E, M extends Requests> = {
-  [K in keyof M]: IsEmpty<Omit<S.Schema.Type<M[K]>, Cruft>> extends true ? {
-      handler: Effect<FetchResponse<Schema.Type<M[K]["success"]>>, Schema.Type<M[K]["failure"]> | E, R>
-      Request: M[K]
-      Reponse: Schema.Type<M[K]["success"]>
-      mapPath: string
-      name: string
-    }
-    : {
-      handler: (
-        req: Omit<S.Schema.Type<M[K]>, Cruft>
-      ) => Effect<
-        FetchResponse<Schema.Type<M[K]["success"]>>,
-        Schema.Type<M[K]["failure"]> | E,
-        R
-      >
-      Request: M[K]
-      Reponse: Schema.Type<M[K]["success"]>
-      mapPath: (req: Omit<S.Schema.Type<M[K]>, Cruft>) => string
-      name: string
-    }
-}
-
-type RequestHandlersE<R, E, M extends Requests> = {
-  [K in keyof M & string as `${K}E`]: IsEmpty<Omit<S.Schema.Type<M[K]>, Cruft>> extends true ? {
-      handler: Effect<
-        FetchResponse<Schema.Encoded<M[K]["success"]>>,
-        Schema.Type<M[K]["failure"]> | E,
-        R
-      >
-      Request: M[K]
-      Reponse: Schema.Type<M[K]["success"]>
-      mapPath: string
-      name: string
-    }
-    : {
-      handler: (
-        req: Omit<
-          S.Schema.Type<M[K]>,
-          Cruft
-        >
-      ) => Effect<
-        FetchResponse<Schema.Encoded<M[K]["success"]>>,
-        Schema.Type<M[K]["failure"]> | E,
-        R
-      >
-      Request: M[K]
-      Reponse: Schema.Type<M[K]["success"]>
-      mapPath: (req: Omit<S.Schema.Type<M[K]>, Cruft>) => string
-      name: string
-    }
-}

package/src/client/fetch.ts

@@ -1,299 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { Effect, HashMap, Option } from "@effect-app/core"
-import { constant } from "@effect-app/core/Function"
-import type { Headers, HttpError, HttpRequestError, HttpResponseError, Method } from "@effect-app/core/http/http-client"
-import type { ResponseError } from "@effect/platform/HttpClientError"
-import { Record } from "effect"
-import type { REST, Schema } from "effect-app/schema"
-import { StringId } from "effect-app/schema"
-import { Path } from "path-parser"
-import qs from "query-string"
-import { HttpClient, HttpClientRequest } from "../http.js"
-import { S } from "../lib.js"
-import { PreludeLogger } from "../logger.js"
-import { ApiConfig } from "./config.js"
-import type { SupportedErrors } from "./errors.js"
-import {
-  InvalidStateError,
-  NotFoundError,
-  NotLoggedInError,
-  OptimisticConcurrencyException,
-  ServiceUnavailableError,
-  UnauthorizedError,
-  ValidationError
-} from "./errors.js"
-
-export type FetchError = HttpError<string>
-
-export class ResError {
-  public readonly _tag = "ResponseError"
-  constructor(public readonly error: unknown) {}
-}
-
-const getClient = Effect.flatMap(
-  HttpClient.HttpClient,
-  (defaultClient) =>
-    Effect.map(ApiConfig.Tag, ({ apiUrl, headers }) =>
-      defaultClient
-        .pipe(
-          HttpClient.filterStatusOk,
-          HttpClient
-            .mapRequest((_) =>
-              _.pipe(
-                HttpClientRequest.acceptJson,
-                HttpClientRequest.prependUrl(apiUrl),
-                HttpClientRequest
-                  .setHeaders({
-                    "request-id": Option.getOrUndefined(Option.flatMap(headers, (_) => HashMap.get(_, "request-id")))
-                      ?? StringId.make(),
-                    ...Option.getOrUndefined(Option.map(headers, (_) => Object.fromEntries(_)))
-                  })
-              )
-            ),
-          HttpClient
-            .tapRequest((r) =>
-              PreludeLogger
-                .logDebug(`[HTTP] ${r.method}`)
-                .pipe(Effect.annotateLogs({
-                  "url": r.url,
-                  "body": r.body._tag === "Uint8Array"
-                    ? new TextDecoder().decode(r.body.body)
-                    : r.body._tag,
-                  "headers": r.headers
-                }))
-            ),
-          HttpClient
-            .mapEffect((_) =>
-              (_.status === 204
-                ? Effect.sync(() => ({ status: _.status, body: void 0, headers: _.headers }))
-                : Effect.map(_.json, (body) => ({ status: _.status, body, headers: _.headers })))
-                .pipe(Effect.withSpan("client.response", { captureStackTrace: false }))
-            )
-        ))
-)
-
-export function fetchApi(
-  method: Method,
-  path: string,
-  body?: unknown,
-  responseError?: S.Schema.AnyNoContext
-) {
-  return Effect.flatMap(getClient, (client) =>
-    (method === "GET"
-      ? client.execute(HttpClientRequest.make(method)(path))
-      : body === undefined
-      ? client.execute(HttpClientRequest.make(method)(path))
-      : HttpClientRequest
-        .make(method)(path)
-        .pipe(HttpClientRequest.bodyJson(body), Effect.flatMap(client.execute)))
-      .pipe(
-        Effect
-          .catchTag(
-            "ResponseError",
-            (err): Effect<FetchResponse<unknown>, ResponseError | SupportedErrors> => {
-              const toError = <R, From, To>(s: Schema<To, From, R>) =>
-                Effect
-                  .flatMap(
-                    err
-                      .response
-                      .json,
-                    (_) => S.decodeUnknown(s)(_).pipe(Effect.catchAll(() => Effect.fail(err)))
-                  )
-                  .pipe(Effect.flatMap(Effect.fail))
-
-              // opposite of api's `defaultErrorHandler`
-              if (err.response.status === 404) {
-                return toError(NotFoundError)
-              }
-              if (err.response.status === 400) {
-                return toError(ValidationError)
-              }
-              if (err.response.status === 401) {
-                return toError(NotLoggedInError)
-              }
-              // TODO: DomainError
-              if (err.response.status === 422) {
-                return responseError
-                  ? toError(S.Union(responseError, InvalidStateError) as any)
-                  : toError(InvalidStateError)
-              }
-              if (err.response.status === 503) {
-                return toError(ServiceUnavailableError)
-              }
-              if (err.response.status === 403) {
-                return toError(UnauthorizedError)
-              }
-              if (err.response.status === 412) {
-                return toError(OptimisticConcurrencyException)
-              }
-              return Effect.fail(err)
-            }
-          ),
-        Effect.catchTags({
-          "ResponseError": (err) =>
-            Effect
-              .orDie(
-                err
-                  .response
-                  .text
-                // TODO
-              )
-              .pipe(Effect
-                .flatMap((_) =>
-                  Effect.fail({
-                    _tag: "HttpErrorResponse" as const,
-                    response: {
-                      body: Option.fromNullable(_),
-                      status: err.response.status,
-                      headers: err.response.headers
-                    }
-                  } as HttpResponseError<unknown>)
-                )),
-          "RequestError": (err) => Effect.fail({ _tag: "HttpErrorRequest", error: err.cause } as HttpRequestError)
-        }),
-        Effect.scoped
-      ))
-}
-
-export function fetchApi2S<
-  RequestR,
-  RequestFrom,
-  RequestTo,
-  ResponseR,
-  ResponseFrom,
-  ResponseTo,
-  ResponseErrorFrom = never,
-  ResponseErrorTo extends { _tag: string } = never
->(
-  request: Schema<RequestTo, RequestFrom, RequestR>,
-  response: Schema<ResponseTo, ResponseFrom, ResponseR>,
-  responseError?: Schema<ResponseErrorTo, ResponseErrorFrom, never>
-) {
-  const encodeRequest = S.encode(request)
-  const decRes = S.decodeUnknown(response)
-  const decodeRes = (u: unknown) => Effect.mapError(decRes(u), (err) => new ResError(err))
-  const parse = mapResponseM(decodeRes)
-  return (method: Method, path: Path) => (req: RequestTo) => {
-    return Effect.andThen(encodeRequest(req), (encoded) =>
-      fetchApi(
-        method,
-        method === "DELETE"
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-          ? makePathWithQuery(path, encoded as any)
-          : makePathWithBody(path, encoded as any),
-        encoded,
-        responseError
-      )
-        .pipe(Effect.flatMap(parse)))
-  }
-}
-
-export function fetchApi3S<RequestA, RequestE, ResponseE = unknown, ResponseA = void>({
-  Request,
-  Response
-}: {
-  // eslint-disable-next-line @typescript-eslint/ban-types
-  Request: REST.RequestSchemed<RequestA, RequestE>
-  // eslint-disable-next-line @typescript-eslint/ban-types
-  Response: REST.ReqRes<ResponseA, ResponseE, any>
-}) {
-  return fetchApi2S(Request, Response, Request.errors)(
-    Request.method,
-    new Path(Request.path)
-  )
-}
-
-export function fetchApi3SE<RequestA, RequestE, ResponseE = unknown, ResponseA = void>({
-  Request,
-  Response
-}: {
-  // eslint-disable-next-line @typescript-eslint/ban-types
-  Request: REST.RequestSchemed<RequestA, RequestE>
-  // eslint-disable-next-line @typescript-eslint/ban-types
-  Response: REST.ReqRes<ResponseA, ResponseE, any>
-}) {
-  const a = fetchApi2S(Request, Response)(
-    Request.method,
-    new Path(Request.path)
-  )
-  const parse = mapResponseM(S.encode(Response))
-  return (req: RequestA) => Effect.flatMap(a(req), parse)
-}
-
-export function makePathWithQuery(
-  path: Path,
-  pars: Record<
-    string,
-    | string
-    | number
-    | boolean
-    | readonly string[]
-    | readonly number[]
-    | readonly boolean[]
-    | null
-  >
-) {
-  const forQs = Record.filter(pars, (_, k) => !path.params.includes(k))
-  const q = forQs // { ...forQs, _: JSON.stringify(forQs) } // TODO: drop completely individual keys from query?, sticking to json only
-  return (
-    path.build(pars, { ignoreSearch: true, ignoreConstraints: true })
-    + (Object.keys(q).length
-      ? "?" + qs.stringify(q)
-      : "")
-  )
-}
-
-export function makePathWithBody(
-  path: Path,
-  pars: Record<
-    string,
-    | string
-    | number
-    | boolean
-    | readonly string[]
-    | readonly number[]
-    | readonly boolean[]
-    | null
-  >
-) {
-  return path.build(pars, { ignoreSearch: true, ignoreConstraints: true })
-}
-
-export function mapResponse<T, A>(map: (t: T) => A) {
-  return (r: FetchResponse<T>): FetchResponse<A> => {
-    return { ...r, body: map(r.body) }
-  }
-}
-
-export function mapResponseM<T, R, E, A>(map: (t: T) => Effect<A, E, R>) {
-  return (r: FetchResponse<T>): Effect<FetchResponse<A>, E, R> => {
-    return Effect
-      .all({
-        body: map(r.body),
-        headers: Effect.sync(() => r.headers),
-        status: Effect.sync(() => r.status)
-      })
-      .pipe(Effect.withSpan("client.decode", { captureStackTrace: false }))
-  }
-}
-export type FetchResponse<T> = { body: T; headers: Headers; status: number }
-
-export const EmptyResponse = Object.freeze({ body: null, headers: {}, status: 404 })
-export const EmptyResponseM = Effect.sync(() => EmptyResponse)
-const EmptyResponseMThunk_ = constant(EmptyResponseM)
-export function EmptyResponseMThunk<T>(): Effect<
-  Readonly<{
-    body: null | T
-    // eslint-disable-next-line @typescript-eslint/ban-types
-    headers: {}
-    status: 404
-  }>,
-  never,
-  unknown
-> {
-  return EmptyResponseMThunk_()
-}
-
-export function getBody<R, E, A>(eff: Effect<FetchResponse<A | null>, E, R>) {
-  return Effect.flatMap(eff, (r) => r.body === null ? Effect.die("Not found") : Effect.sync(() => r.body))
-}