effect-app 1.20.0 → 1.21.0

package/src/client/clientFor.ts

@@ -1,238 +1,316 @@
 /* eslint-disable @typescript-eslint/no-unsafe-argument */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
-import { Effect, flow, Predicate } from "@effect-app/core"
+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 { Record } from "effect"
+import { S } from "effect-app"
+import { ApiConfig } from "effect-app/client"
+import { HttpClient, HttpClientRequest } from "effect-app/http"
 import type { Schema } from "effect-app/schema"
-import { REST } from "effect-app/schema"
+import { typedKeysOf } from "effect-app/utils"
+import type * as Request from "effect/Request"
 import { Path } from "path-parser"
-import type { HttpClient } from "../http.js"
-import { S } from "../lib.js"
-import { typedKeysOf } from "../utils.js"
-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,
-  ResError
-} from "./fetch.js"
-
-export * from "./config.js"
+import qs from "query-string"
 
-type Requests = Record<string, any>
-type AnyRequest =
-  & Omit<
-    REST.QueryRequest<any, any, any, any, any, any>,
-    "method"
+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
   >
-  & REST.RequestSchemed<any, any>
+) {
+  return path.build(pars, { ignoreSearch: true, ignoreConstraints: true })
+}
+
+/** @deprecated will be removed in favour of directly using A/E */
+export interface FetchResponse<T> {
+  body: T
+  headers: Headers
+  status: number
+}
 
-const cache = new Map<any, Client<any>>()
+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,
-    SupportedErrors | FetchError | ResError,
+    never, // SupportedErrors | FetchError | ResError,
     M
   >
   & RequestHandlersE<
     ApiConfig | HttpClient.HttpClient.Service,
-    SupportedErrors | FetchError | ResError,
+    never, // SupportedErrors | FetchError | ResError,
     M
   >
 
-export function clientFor<M extends Requests>(
-  models: M
-): Client<Omit<M, "meta">> {
-  const found = cache.get(models)
-  if (found) {
-    return found
+export function makeClientFor(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
   }
-  const m = clientFor_(models)
-  cache.set(models, m)
-  return m
 }
 
-function clientFor_<M extends Requests>(models: 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 { Response: any } ? K : never]: Requests[K] extends { Response: any }
-      ? Requests[K]
-      : never
+    [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].Request || Object.keys(models[cur]).some((_) => _.endsWith("Request")) /* bwc */)
+      && (models[cur].success)
     ) {
       acc[cur as keyof Filtered] = models[cur]
     }
     return acc
-  }, {} as Filtered)
+  }, {} 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)
-    // ignore module interop with automatic default exports..
-    .filter((x) => x !== "default" && x !== "meta")
     .reduce((prev, cur) => {
-      const h = filtered[cur]
+      const h = filtered[cur]!
 
-      const Request_ = REST.extractRequest(h) as AnyRequest
-      const Response = REST.extractResponse(h)
+      const Request = h
+      const Response = h.success
 
-      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 encodeRequest = S.encodeSync(
+        Request as unknown as S.Schema<any, any>
+      )
 
-      const b = Object.assign({}, h, { Request, Response })
+      const requestName = `${meta.moduleName}.${cur as string}`
+        .replaceAll(".js", "")
 
-      const meta = {
+      const requestMeta = {
+        method: "POST", // TODO
         Request,
         Response,
-        mapPath: Request.path,
+        mapPath: requestName,
         name: requestName
       }
 
-      const res = Response as Schema<any>
-      const parseResponse = flow(S.decodeUnknown(res), (_) => Effect.mapError(_, (err) => new ResError(err)))
-      const parseResponseE = flow(
-        S.decodeUnknown(S.encodedSchema(res)),
-        (_) => Effect.mapError(_, (err) => new ResError(err))
+      const client = baseClient.pipe(
+        Effect.andThen(HttpClient.mapRequest(HttpClientRequest.appendUrlParam("action", cur as string))),
+        Effect.andThen(resolver)
       )
 
-      const path = new Path(Request.path)
-      const parse = mapResponseM(parseResponse)
-      const parseE = mapResponseM(parseResponseE)
-
-      // 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)
+      const fields = Struct.omit(Request.fields, "_tag")
+      const p = requestName
+      const path = new Path(p) // TODO
       // @ts-expect-error doc
-      prev[cur] = Request.method === "GET"
-        ? fields.length === 0
+      prev[cur] = requestMeta.method === "GET"
+        ? Object.keys(fields).length === 0
           ? {
-            handler: fetchApi(Request.method, Request.path, undefined, Request.errors)
+            handler: client
               .pipe(
-                Effect.flatMap(parse),
+                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)
               ),
-            ...meta
+            ...requestMeta
           }
           : {
             handler: (req: any) =>
-              fetchApi(Request.method, makePathWithQuery(path, S.encodeSync(Request)(req)), undefined, Request.errors)
+              client
                 .pipe(
-                  Effect.flatMap(parse),
+                  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)
                 ),
-            ...meta,
-            mapPath: (req: any) => req ? makePathWithQuery(path, S.encodeSync(Request)(req)) : Request.path
+            ...requestMeta,
+            mapPath: (req: any) => req ? makePathWithQuery(path, encodeRequest(req)) : p
           }
-        : fields.length === 0
+        : Object.keys(fields).length === 0
         ? {
-          handler: fetchApi3S(b)({}).pipe(Effect.withSpan("client.request " + requestName, {
-            captureStackTrace: false,
-            attributes: { "request.name": requestName }
-          })),
-          ...meta
+          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) =>
-            fetchApi3S(b)(req).pipe(Effect.withSpan("client.request " + requestName, {
-              captureStackTrace: false,
-              attributes: { "request.name": requestName }
-            })),
+            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)
+              ),
 
-          ...meta,
+          ...requestMeta,
           mapPath: (req: any) =>
             req
-              ? Request.method === "DELETE"
-                ? makePathWithQuery(path, S.encodeSync(Request)(req))
-                : makePathWithBody(path, S.encodeSync(Request)(req))
-              : Request.path
+              ? requestMeta.method === "DELETE"
+                ? makePathWithQuery(path, encodeRequest(req))
+                : makePathWithBody(path, encodeRequest(req))
+              : p
         }
 
       // generate handler
 
       // @ts-expect-error doc
-      prev[`${cur}E`] = Request.method === "GET"
-        ? fields.length === 0
+      prev[`${cur}E`] = requestMeta.method === "GET"
+        ? Object.keys(fields).length === 0
           ? {
-            handler: fetchApi(Request.method, Request.path)
+            handler: client
               .pipe(
-                Effect.flatMap(parseE),
+                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)
               ),
-            ...meta
+            ...requestMeta
           }
           : {
             handler: (req: any) =>
-              fetchApi(Request.method, makePathWithQuery(path, S.encodeSync(Request)(req)))
+              client
                 .pipe(
-                  Effect.flatMap(parseE),
+                  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)
                 ),
 
-            ...meta,
-            mapPath: (req: any) => req ? makePathWithQuery(path, S.encodeSync(Request)(req)) : Request.path
+            ...requestMeta,
+            mapPath: (req: any) => req ? makePathWithQuery(path, encodeRequest(req)) : p
           }
-        : fields.length === 0
+        : Object.keys(fields).length === 0
         ? {
-          handler: fetchApi3SE(b)({}).pipe(Effect.withSpan("client.request " + requestName, {
-            captureStackTrace: false,
-            attributes: { "request.name": requestName }
-          })),
-          ...meta
+          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) =>
-            fetchApi3SE(b)(req).pipe(Effect.withSpan("client.request " + requestName, {
-              captureStackTrace: false,
-              attributes: { "request.name": requestName }
-            })),
+            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)
+              ),
 
-          ...meta,
+          ...requestMeta,
           mapPath: (req: any) =>
             req
-              ? Request.method === "DELETE"
-                ? makePathWithQuery(path, S.encodeSync(Request)(req))
-                : makePathWithBody(path, S.encodeSync(Request)(req))
-              : Request.path
+              ? requestMeta.method === "DELETE"
+                ? makePathWithQuery(path, encodeRequest(req))
+                : makePathWithBody(path, encodeRequest(req))
+              : p
         }
       // generate handler
 
@@ -248,56 +326,61 @@ export type ExtractEResponse<T> = T extends Schema<any, any, any> ? Schema.Encod
   : T extends unknown ? void
   : never
 
-type HasEmptyTo<T extends Schema<any, any, any>> = keyof Schema.Type<T> extends never ? true
+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]: 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]>>
+  [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: S.Schema.Type<REST.GetRequest<M[K]>>
+        req: Omit<S.Schema.Type<M[K]>, Cruft>
       ) => Effect<
-        FetchResponse<ExtractResponse<REST.GetResponse<M[K]>>>,
-        E,
+        FetchResponse<Schema.Type<M[K]["success"]>>,
+        Schema.Type<M[K]["failure"]> | E,
         R
       >
-      Request: REST.GetRequest<M[K]>
-      Reponse: ExtractResponse<REST.GetResponse<M[K]>>
-      mapPath: (req: S.Schema.Type<REST.GetRequest<M[K]>>) => string
+      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`]: HasEmptyTo<REST.GetRequest<M[K]>> extends true ? {
+  [K in keyof M & string as `${K}E`]: IsEmpty<Omit<S.Schema.Type<M[K]>, Cruft>> extends true ? {
       handler: Effect<
-        FetchResponse<ExtractEResponse<REST.GetResponse<M[K]>>>,
-        E,
+        FetchResponse<Schema.Encoded<M[K]["success"]>>,
+        Schema.Type<M[K]["failure"]> | E,
         R
       >
-      Request: REST.GetRequest<M[K]>
-      Reponse: ExtractResponse<REST.GetResponse<M[K]>>
+      Request: M[K]
+      Reponse: Schema.Type<M[K]["success"]>
       mapPath: string
       name: string
     }
     : {
       handler: (
-        req: S.Schema.Type<REST.GetRequest<M[K]>>
+        req: Omit<
+          S.Schema.Type<M[K]>,
+          Cruft
+        >
       ) => Effect<
-        FetchResponse<ExtractEResponse<REST.GetResponse<M[K]>>>,
-        E,
+        FetchResponse<Schema.Encoded<M[K]["success"]>>,
+        Schema.Type<M[K]["failure"]> | E,
         R
       >
-      Request: REST.GetRequest<M[K]>
-      Reponse: ExtractResponse<REST.GetResponse<M[K]>>
-      mapPath: (req: S.Schema.Type<REST.GetRequest<M[K]>>) => string
+      Request: M[K]
+      Reponse: Schema.Type<M[K]["success"]>
+      mapPath: (req: Omit<S.Schema.Type<M[K]>, Cruft>) => string
       name: string
     }
 }

package/src/client.ts

@@ -2,5 +2,4 @@
 export * from "./client/clientFor.js"
 export * from "./client/config.js"
 export * from "./client/errors.js"
-export * from "./client/fetch.js"
 // codegen:end

package/vitest.config.ts.timestamp-1670862388823.mjs

@@ -0,0 +1,23 @@
+// vitest.config.ts
+import { defineConfig } from "file:///Users/patrickroza/Projects/Personal/effect-ts-app/libs/node_modules/.pnpm/vite@4.0.0_@types+node@18.11.12/node_modules/vite/dist/node/index.js";
+
+// ../../vite.config.base.ts
+import { tsPlugin } from "file:///Users/patrickroza/Projects/Personal/effect-ts-app/libs/packages/compiler/dist/vitePlugin.js";
+function makeConfig() {
+  return {
+    plugins: [tsPlugin({})],
+    test: {
+      include: ["./_src/**/*.test.{js,mjs,cjs,ts,mts,cts,jsx,tsx}"],
+      exclude: ["./_test/**/*"],
+      reporters: "verbose",
+      globals: true
+    }
+  };
+}
+
+// vitest.config.ts
+var vitest_config_default = defineConfig(makeConfig());
+export {
+  vitest_config_default as default
+};
+//# sourceMappingURL=data:application/json;base64,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