effect-app 0.152.0

package/_src/client/clientFor.ts

@@ -0,0 +1,260 @@
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import { REST } from "effect-app/schema"
+import * as utils from "effect-app/utils"
+import { Path } from "path-parser"
+import type { ApiConfig } from "./config.js"
+import type { SupportedErrors } from "./errors.js"
+import type { FetchError, FetchResponse } from "./fetch.js"
+import {
+  fetchApi,
+  fetchApi3S,
+  fetchApi3SE,
+  makePathWithBody,
+  makePathWithQuery,
+  mapResponseM,
+  ResponseError
+} from "./fetch.js"
+
+export * from "./config.js"
+
+type Requests = Record<string, any>
+type AnyRequest =
+  & Omit<
+    REST.QueryRequest<any, any, any, any, any, any>,
+    "method"
+  >
+  & REST.RequestSchemed<any, any>
+
+const cache = new Map<any, Client<any>>()
+
+export type Client<M extends Requests> =
+  & RequestHandlers<
+    ApiConfig | HttpClient.Default,
+    SupportedErrors | FetchError | ResponseError,
+    M
+  >
+  & RequestHandlersE<
+    ApiConfig | HttpClient.Default,
+    SupportedErrors | FetchError | ResponseError,
+    M
+  >
+
+export function clientFor<M extends Requests>(
+  models: M
+): Client<Omit<M, "meta">> {
+  const found = cache.get(models)
+  if (found) {
+    return found
+  }
+  const m = clientFor_(models)
+  cache.set(models, m)
+  return m
+}
+
+function clientFor_<M extends Requests>(models: M) {
+  return (models
+    .$$
+    .keys
+    // ignore module interop with automatic default exports..
+    .filter((x) => x !== "default" && x !== "meta")
+    .reduce((prev, cur) => {
+      const h = models[cur]
+
+      const Request_ = REST.extractRequest(h) as AnyRequest
+      const Response = REST.extractResponse(h)
+
+      // @ts-expect-error doc
+      const actionName = utils.uncapitalize(cur)
+      const m = (models as any).meta as { moduleName: string }
+      if (!m) throw new Error("No meta defined in Resource!")
+      const requestName = `${m.moduleName}.${cur as string}`
+        .replaceAll(".js", "")
+
+      const Request = class extends (Request_ as any) {
+        static path = "/" + requestName + (Request_.path === "/" ? "" : Request_.path)
+        static method = Request_.method as REST.SupportedMethods === "AUTO"
+          ? REST.determineMethod(cur as string, Request_)
+          : Request_.method
+      } as unknown as AnyRequest
+
+      if ((Request_ as any).method === "AUTO") {
+        Object.assign(Request, {
+          [Request.method === "GET" || Request.method === "DELETE" ? "Query" : "Body"]: (Request_ as any).Auto
+        })
+      }
+
+      const b = Object.assign({}, h, { Request, Response })
+
+      const meta = {
+        Request,
+        Response,
+        mapPath: Request.path
+      }
+
+      const res = Response as Schema<any>
+      const parseResponse = flow(res.decodeUnknown, (_) => _.mapError((err) => new ResponseError(err)))
+
+      const parseResponseE = flow(parseResponse, (x) => x.andThen(res.encode))
+
+      const path = new Path(Request.path)
+
+      // TODO: look into ast, look for propertySignatures, etc.
+      // TODO: and fix type wise
+      // if we don't need fields, then also dont require an argument.
+      const fields = [Request.Body, Request.Query, Request.Path]
+        .filter((x) => x)
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        .flatMap((x) => x.ast.propertySignatures)
+      // @ts-expect-error doc
+      prev[actionName] = Request.method === "GET"
+        ? fields.length === 0
+          ? {
+            handler: fetchApi(Request.method, Request.path)
+              .flatMap(mapResponseM(parseResponse))
+              .withSpan("client.request", {
+                attributes: { "request.name": requestName }
+              }),
+            ...meta
+          }
+          : {
+            handler: (req: any) =>
+              fetchApi(Request.method, makePathWithQuery(path, Request.encodeSync(req)))
+                .flatMap(mapResponseM(parseResponse))
+                .withSpan("client.request", {
+                  attributes: { "request.name": requestName }
+                }),
+            ...meta,
+            mapPath: (req: any) => req ? makePathWithQuery(path, Request.encodeSync(req)) : Request.path
+          }
+        : fields.length === 0
+        ? {
+          handler: fetchApi3S(b)({}).withSpan("client.request", {
+            attributes: { "request.name": requestName }
+          }),
+          ...meta
+        }
+        : {
+          handler: (req: any) =>
+            fetchApi3S(b)(req).withSpan("client.request", {
+              attributes: { "request.name": requestName }
+            }),
+
+          ...meta,
+          mapPath: (req: any) =>
+            req
+              ? Request.method === "DELETE"
+                ? makePathWithQuery(path, Request.encodeSync(req))
+                : makePathWithBody(path, Request.encodeSync(req))
+              : Request.path
+        }
+
+      // generate handler
+
+      // @ts-expect-error doc
+      prev[`${actionName}E`] = Request.method === "GET"
+        ? fields.length === 0
+          ? {
+            handler: fetchApi(Request.method, Request.path)
+              .flatMap(mapResponseM(parseResponseE))
+              .withSpan("client.request", {
+                attributes: { "request.name": requestName }
+              }),
+            ...meta
+          }
+          : {
+            handler: (req: any) =>
+              fetchApi(Request.method, makePathWithQuery(path, Request.encodeSync(req)))
+                .flatMap(mapResponseM(parseResponseE))
+                .withSpan("client.request", {
+                  attributes: { "request.name": requestName }
+                }),
+
+            ...meta,
+            mapPath: (req: any) => req ? makePathWithQuery(path, Request.encodeSync(req)) : Request.path
+          }
+        : fields.length === 0
+        ? {
+          handler: fetchApi3SE(b)({}).withSpan("client.request", {
+            attributes: { "request.name": requestName }
+          }),
+          ...meta
+        }
+        : {
+          handler: (req: any) =>
+            fetchApi3SE(b)(req).withSpan("client.request", {
+              attributes: { "request.name": requestName }
+            }),
+
+          ...meta,
+          mapPath: (req: any) =>
+            req
+              ? Request.method === "DELETE"
+                ? makePathWithQuery(path, Request.encodeSync(req))
+                : makePathWithBody(path, Request.encodeSync(req))
+              : Request.path
+        }
+      // generate handler
+
+      return prev
+    }, {} as Client<M>))
+}
+
+export type ExtractResponse<T> = T extends Schema<any, any, any> ? Schema.To<T>
+  : T extends unknown ? void
+  : never
+
+export type ExtractEResponse<T> = T extends Schema<any, any, any> ? Schema.From<T>
+  : T extends unknown ? void
+  : never
+
+type HasEmptyTo<T extends Schema<any, any, any>> = T extends { struct: Schema<any, any, any> }
+  ? Schema.To<T["struct"]> extends Record<any, never> ? true : Schema.To<T> extends Record<any, never> ? true : false
+  : false
+
+type RequestHandlers<R, E, M extends Requests> = {
+  [K in keyof M & string as Uncapitalize<K>]: HasEmptyTo<REST.GetRequest<M[K]>> extends true ? {
+      handler: Effect<FetchResponse<ExtractResponse<REST.GetResponse<M[K]>>>, E, R>
+      Request: REST.GetRequest<M[K]>
+      Reponse: ExtractResponse<REST.GetResponse<M[K]>>
+      mapPath: string
+    }
+    : {
+      handler: (
+        req: InstanceType<REST.GetRequest<M[K]>>
+      ) => Effect<
+        FetchResponse<ExtractResponse<REST.GetResponse<M[K]>>>,
+        E,
+        R
+      >
+      Request: REST.GetRequest<M[K]>
+      Reponse: ExtractResponse<REST.GetResponse<M[K]>>
+      mapPath: (req: InstanceType<REST.GetRequest<M[K]>>) => string
+    }
+}
+
+type RequestHandlersE<R, E, M extends Requests> = {
+  [K in keyof M & string as `${Uncapitalize<K>}E`]: HasEmptyTo<REST.GetRequest<M[K]>> extends true ? {
+      handler: Effect<
+        FetchResponse<ExtractEResponse<REST.GetResponse<M[K]>>>,
+        E,
+        R
+      >
+      Request: REST.GetRequest<M[K]>
+      Reponse: ExtractResponse<REST.GetResponse<M[K]>>
+      mapPath: string
+    }
+    : {
+      handler: (
+        req: InstanceType<REST.GetRequest<M[K]>>
+      ) => Effect<
+        FetchResponse<ExtractEResponse<REST.GetResponse<M[K]>>>,
+        E,
+        R
+      >
+      Request: REST.GetRequest<M[K]>
+      Reponse: ExtractResponse<REST.GetResponse<M[K]>>
+      mapPath: (req: InstanceType<REST.GetRequest<M[K]>>) => string
+    }
+}

package/_src/client/config.ts

@@ -0,0 +1,13 @@
+export interface ApiConfig {
+  apiUrl: string
+  headers: Option<HashMap<string, string>>
+}
+
+const tag = GenericTag<ApiConfig>("@services/tag")
+export const layer = (config: ApiConfig) => tag.makeLayer(config)
+export const ApiConfig = {
+  Tag: tag,
+  layer
+}
+
+export const getConfig = <R, E, A>(self: (cfg: ApiConfig) => Effect<A, E, R>) => tag.flatMap(self)

package/_src/client/errors.ts

@@ -0,0 +1,129 @@
+import { TaggedError } from "effect-app/schema"
+
+/** @tsplus type NotFoundError */
+@useClassFeaturesForSchema
+// eslint-disable-next-line unused-imports/no-unused-vars
+// @ts-expect-error type not used
+export class NotFoundError<ItemType = string> extends TaggedError<NotFoundError<ItemType>>()("NotFoundError", {
+  type: string,
+  id: unknown
+}) {
+  override get message() {
+    return `Didn't find ${this.type}#${JSON.stringify(this.id)}`
+  }
+}
+
+/** @tsplus type InvalidStateError */
+@useClassFeaturesForSchema
+export class InvalidStateError extends TaggedError<InvalidStateError>()("InvalidStateError", {
+  message: string
+}) {
+  constructor(messageOrObject: string | { message: string }, disableValidation = false) {
+    super(typeof messageOrObject === "object" ? messageOrObject : { message: messageOrObject }, disableValidation)
+  }
+}
+
+/** @tsplus type ValidationError */
+@useClassFeaturesForSchema
+export class ValidationError extends TaggedError<ValidationError>()("ValidationError", {
+  errors: array(unknown) // meh
+}) {
+  override get message() {
+    return `Validation failed: ${this.errors.map((e) => JSON.stringify(e)).join(", ")}`
+  }
+}
+
+/** @tsplus type NotLoggedInError */
+@useClassFeaturesForSchema
+export class NotLoggedInError extends TaggedError<NotLoggedInError>()("NotLoggedInError", {
+  message: string.optional()
+}) {
+  constructor(messageOrObject?: string | { message?: string }, disableValidation = false) {
+    super(typeof messageOrObject === "object" ? messageOrObject : { message: messageOrObject }, disableValidation)
+  }
+}
+
+/**
+ * The user carries a valid Userprofile, but there is a problem with the login none the less.
+ */
+/** @tsplus type LoginError */
+@useClassFeaturesForSchema
+export class LoginError extends TaggedError<LoginError>()("NotLoggedInError", {
+  message: string.optional()
+}) {
+  constructor(messageOrObject?: string | { message?: string }, disableValidation = false) {
+    super(typeof messageOrObject === "object" ? messageOrObject : { message: messageOrObject }, disableValidation)
+  }
+}
+
+/** @tsplus type UnauthorizedError */
+@useClassFeaturesForSchema
+export class UnauthorizedError extends TaggedError<UnauthorizedError>()("UnauthorizedError", {
+  message: string.optional()
+}) {
+  constructor(messageOrObject?: string | { message?: string }, disableValidation = false) {
+    super(typeof messageOrObject === "object" ? messageOrObject : { message: messageOrObject }, disableValidation)
+  }
+}
+
+type OptimisticConcurrencyDetails = {
+  readonly type: string
+  readonly id: string
+  readonly current?: string | undefined
+  readonly found?: string | undefined
+}
+
+/** @tsplus type OptimisticConcurrencyException */
+@useClassFeaturesForSchema
+export class OptimisticConcurrencyException extends TaggedError<OptimisticConcurrencyException>()(
+  "OptimisticConcurrencyException",
+  { message: string }
+) {
+  readonly details?: OptimisticConcurrencyDetails
+  constructor(
+    args: OptimisticConcurrencyDetails | { message: string },
+    disableValidation = false
+  ) {
+    super("message" in args ? args : { message: `Existing ${args.type} ${args.id} record changed` }, disableValidation)
+    if (!("message" in args)) {
+      this.details = args
+    }
+  }
+}
+
+const MutationOnlyErrors = [
+  InvalidStateError,
+  OptimisticConcurrencyException
+] as const
+
+const GeneralErrors = [
+  NotFoundError,
+  NotLoggedInError,
+  LoginError,
+  UnauthorizedError,
+  ValidationError
+] as const
+
+export const SupportedErrors = union(
+  ...MutationOnlyErrors,
+  ...GeneralErrors
+)
+// .pipe(named("SupportedErrors"))
+// .pipe(withDefaults)
+export type SupportedErrors = Schema.To<typeof SupportedErrors>
+
+// ideal?
+// export const QueryErrors = union({ ...GeneralErrors })
+//   .pipe(named("QueryErrors"))
+//   .pipe(withDefaults)
+// export type QueryErrors = Schema.To<typeof QueryErrors>
+// export const MutationErrors = union({ ...GeneralErrors, ...GeneralErrors })
+//   .pipe(named("MutationErrors"))
+//   .pipe(withDefaults)
+
+// export type MutationErrors = Schema.To<typeof MutationErrors>
+
+export const MutationErrors = SupportedErrors
+export const QueryErrors = SupportedErrors
+export type MutationErrors = Schema.To<typeof MutationErrors>
+export type QueryErrors = Schema.To<typeof QueryErrors>

package/_src/client/fetch.ts

@@ -0,0 +1,253 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { constant } from "@effect-app/core/Function"
+import type { Headers, HttpError, HttpRequestError, HttpResponseError, Method } from "@effect-app/core/http/http-client"
+import type { REST } from "effect-app/schema"
+import { Path } from "path-parser"
+import qs from "query-string"
+import { ApiConfig } from "./config.js"
+import {
+  InvalidStateError,
+  NotFoundError,
+  NotLoggedInError,
+  OptimisticConcurrencyException,
+  UnauthorizedError,
+  ValidationError
+} from "./errors.js"
+
+export type FetchError = HttpError<string>
+
+export class ResponseError {
+  public readonly _tag = "ResponseError"
+  constructor(public readonly error: unknown) {}
+}
+
+const getClient = HttpClient.flatMap((defaultClient) =>
+  ApiConfig
+    .Tag
+    .map(({ apiUrl, headers }) =>
+      defaultClient
+        .filterStatusOk
+        .mapRequest((_) =>
+          _
+            .acceptJson
+            .prependUrl(apiUrl)
+            .setHeaders({
+              "request-id": headers.flatMap((_) => _.get("request-id")).value ?? StringId.make(),
+              ...headers.map((_) => Object.fromEntries(_)).value
+            })
+        )
+        .tapRequest((r) =>
+          Effect
+            .logDebug(`[HTTP] ${r.method}`)
+            .annotateLogs("url", r.url)
+            .annotateLogs("body", r.body._tag === "Uint8Array" ? new TextDecoder().decode(r.body.body) : r.body._tag)
+            .annotateLogs("headers", r.headers)
+        )
+        .mapEffect((_) =>
+          _.status === 204
+            ? Effect.sync(() => ({ status: _.status, body: void 0, headers: _.headers }))
+            : _.json.map((body) => ({ status: _.status, body, headers: _.headers }))
+        )
+        .catchTag(
+          "ResponseError",
+          (err) => {
+            const toError = <R, From, To>(s: Schema<To, From, R>) =>
+              err.response.json.flatMap((_) => s.decodeUnknown(_).catchAll(() => Effect.fail(err))).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)
+            }
+            if (err.response.status === 422) {
+              return toError(InvalidStateError)
+            }
+            if (err.response.status === 403) {
+              return toError(UnauthorizedError)
+            }
+            if (err.response.status === 412) {
+              return toError(OptimisticConcurrencyException)
+            }
+            return Effect.fail(err)
+          }
+        )
+        .catchTags({
+          "ResponseError": (err) =>
+            err
+              .response
+              .text
+              // TODO
+              .orDie
+              .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.error } as HttpRequestError)
+        })
+    )
+)
+
+export function fetchApi(
+  method: Method,
+  path: string,
+  body?: unknown
+) {
+  return getClient
+    .flatMap((client) =>
+      (method === "GET"
+        ? client.request(ClientRequest.make(method)(path))
+        : body === undefined
+        ? client.request(
+          ClientRequest
+            .make(method)(path)
+        )
+        : client.request(
+          ClientRequest
+            .make(method)(path)
+            .jsonBody(body)
+        ))
+        .withSpan("http.request", { attributes: { "http.method": method, "http.url": path } })
+    )
+}
+
+export function fetchApi2S<RequestR, RequestFrom, RequestTo, ResponseR, ResponseFrom, ResponseTo>(
+  request: Schema<RequestTo, RequestFrom, RequestR>,
+  response: Schema<ResponseTo, ResponseFrom, ResponseR>
+) {
+  const encodeRequest = request.encode
+  const decRes = response.decodeUnknown
+  const decodeRes = (u: unknown) => decRes(u).mapError((err) => new ResponseError(err))
+  return (method: Method, path: Path) => (req: RequestTo) => {
+    return encodeRequest(req).andThen((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
+      )
+        .flatMap(mapResponseM(decodeRes))
+        .map((i) => ({
+          ...i,
+          // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+          body: i.body as ResponseTo
+        }))
+    )
+  }
+}
+
+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.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 encode = S.encode(Response)
+  return (req: RequestA) => a(req).flatMap(mapResponseM((_) => encode(_)))
+}
+
+export function makePathWithQuery(
+  path: Path,
+  pars: Record<
+    string,
+    | string
+    | number
+    | boolean
+    | readonly string[]
+    | readonly number[]
+    | readonly boolean[]
+    | null
+  >
+) {
+  const forQs = ReadonlyRecord.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)
+    })
+  }
+}
+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 eff.flatMap((r) => r.body === null ? Effect.die("Not found") : Effect.sync(() => r.body))
+}

package/_src/client.ts

@@ -0,0 +1,7 @@
+// codegen:start {preset: barrel, include: ./client/*.ts}
+export * from "./client/clientFor.js"
+export * from "./client/config.js"
+export * from "./client/errors.js"
+export * from "./client/fetch.js"
+export * from "./client/QueryResult.js"
+// codegen:end

package/_src/faker.ts

@@ -0,0 +1,32 @@
+// FILE HAS SIDE EFFECTS!
+import type { Faker } from "@faker-js/faker"
+import type * as FC from "fast-check"
+
+// TODO: inject faker differently, so we dont care about multiple instances of library.
+
+// eslint-disable-next-line prefer-const
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let faker: Faker = undefined as any as Faker
+export function setFaker(f: Faker) {
+  faker = f
+}
+
+export function getFaker() {
+  if (!faker) throw new Error("You forgot to load faker library")
+  return faker
+}
+
+export const fakerToArb = <T>(fakerGen: () => T) => (fc: typeof FC) => {
+  return fc
+    .integer()
+    .noBias() // same probability to generate each of the allowed integers
+    .noShrink() // shrink on a seed makes no sense
+    .map((seed) => {
+      faker.seed(seed) // seed the generator
+      return fakerGen() // call it
+    })
+}
+
+export const fakerArb = <T>(
+  gen: (fake: Faker) => () => T
+): (a: any) => FC.Arbitrary<T> => fakerToArb(() => gen(getFaker())())