effect-app 2.35.0 → 2.36.1

package/src/client/apiClientFactory.ts

@@ -1,48 +1,10 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import type { Rpc } from "@effect/rpc"
-import { RpcResolver, RpcResolverNoStream } from "@effect/rpc"
-import type { RpcRouter } from "@effect/rpc/RpcRouter"
-import { HttpBody, HttpClient, HttpClientRequest, HttpClientResponse } from "../http.js"
-import type { RequestResolver, Schema } from "../internal/lib.js"
-import { Config, Context, Effect, flow, HashMap, Layer, Option, pipe, Predicate, S, Struct } from "../internal/lib.js"
-import { typedKeysOf } from "../utils.js"
+import { Rpc, RpcClient, RpcGroup, RpcSerialization } from "@effect/rpc"
+import { HttpClient, HttpClientRequest } from "../http.js"
+import { Config, Context, Effect, flow, HashMap, Layer, ManagedRuntime, Option, Predicate, S, Struct } from "../internal/lib.js"
+import { typedKeysOf, typedValuesOf } from "../utils.js"
 import type { Client, Requests } from "./clientFor.js"
 
-export const make = <R extends RpcRouter<any, any>>(
-  client: HttpClient.HttpClient
-): RequestResolver.RequestResolver<
-  Rpc.Request<RpcRouter.Request<R>>,
-  Schema.SerializableWithResult.Context<RpcRouter.Request<R>>
-> =>
-  RpcResolverNoStream.make((requests) =>
-    client
-      .post("", {
-        body: HttpBody.unsafeJson(requests)
-      })
-      .pipe(
-        Effect.flatMap((_) =>
-          pipe(
-            _,
-            HttpClientResponse.filterStatus((_) => _ === 200 || _ === 418 || _ === 422)
-            // Effect.tapErrorCause(() =>
-            //   _.text.pipe(
-            //     Effect.orElseSucceed(() => undefined),
-            //     Effect.flatMap((body) =>
-            //       Effect.annotateCurrentSpan({ "response.headers": redactUnwrap(_.headers), "response.body": body }).pipe(
-            //         Effect.andThen(
-            //           Effect.logError("RPC error", { responseHeaders: redactUnwrap(_.headers), responseBody: body })
-            //         )
-            //       )
-            //     )
-            //   )
-            // )
-          )
-        ),
-        Effect.flatMap((_) => _.json),
-        Effect.scoped
-      )
-  )<R>()
-
 export interface ApiConfig {
   url: string
   headers: Option<HashMap<string, string>>
@@ -67,131 +29,240 @@ type Req = S.Schema.All & {
   config?: Record<string, any>
 }
 
-const makeApiClientFactory = (config: ApiConfig) =>
-  Effect.gen(function*() {
-    const baseClient = yield* HttpClient.HttpClient
-    const client = baseClient.pipe(
-      HttpClient.mapRequest(HttpClientRequest.prependUrl(config.url + "/rpc")),
-      HttpClient.mapRequest(
-        HttpClientRequest.setHeaders(config.headers.pipe(Option.getOrElse(() => HashMap.empty())))
+class RequestName extends Context.Reference<RequestName>()("RequestName", {
+  defaultValue: () => ({ requestName: "Unspecified", moduleName: "Error" })
+}) {}
+
+const makeProtocol = (config: ApiConfig) =>
+  Effect
+    .gen(function*() {
+      const baseClient = yield* HttpClient.HttpClient
+      const client = baseClient.pipe(
+        HttpClient.mapRequest(HttpClientRequest.prependUrl(config.url + "/rpc")),
+        HttpClient.mapRequest(
+          HttpClientRequest.setHeaders(config.headers.pipe(Option.getOrElse(() => HashMap.empty())))
+        ),
+        HttpClient.mapRequestEffect((req) =>
+          RequestName.pipe(
+            Effect.map((ctx) =>
+              flow(
+                HttpClientRequest.appendUrlParam("action", ctx.requestName),
+                HttpClientRequest.appendUrl("/" + ctx.moduleName)
+              )(req)
+            )
+          )
+        )
       )
-    )
 
-    const makeClientFor = <M extends Requests>(resource: M, requestLevelLayers = Layer.empty) => {
-      type Filtered = {
-        [K in keyof Requests as Requests[K] extends Req ? K : never]: Requests[K] extends Req ? Requests[K] : never
-      }
-      // TODO: Record.filter
-      const filtered = typedKeysOf(resource).reduce((acc, cur) => {
-        if (
-          Predicate.isObject(resource[cur])
-          && (resource[cur].success)
-        ) {
-          acc[cur as keyof Filtered] = resource[cur]
-        }
-        return acc
-      }, {} as Record<keyof Filtered, Req>)
+      return Layer.mergeAll(
+        RpcSerialization.layerJson,
+        Layer.succeed(HttpClient.HttpClient, client)
+      )
+    })
+    .pipe(Layer.unwrapEffect)
 
-      const meta = (resource as any).meta as { moduleName: string }
-      if (!meta) throw new Error("No meta defined in Resource!")
+type RpcHandlers<M extends Requests> = {
+  [K in keyof M]: Rpc.Rpc<M[K]["_tag"], M[K], M[K]["success"], M[K]["failure"]>
+}
 
-      const resolver = flow(
-        make<RpcRouter<any, any>>,
-        (_) => RpcResolver.toClient(_ as any)
-      )
+const getFiltered = <M extends Requests>(resource: M) => {
+  type Filtered = {
+    [K in keyof M as M[K] extends Req ? K : never]: M[K] extends Req ? M[K] : never
+  }
+  // TODO: Record.filter
+  const filtered = typedKeysOf(resource).reduce((acc, cur) => {
+    if (
+      Predicate.isObject(resource[cur])
+      && (resource[cur].success)
+    ) {
+      acc[cur as keyof Filtered] = resource[cur]
+    }
+    return acc
+  }, {} as Record<keyof Filtered, Req>)
+
+  return filtered as unknown as Filtered
+}
 
-      const baseClient = HttpClient.mapRequest(client, HttpClientRequest.appendUrl("/" + meta.moduleName))
+export const getMeta = <M extends Requests>(resource: M) => {
+  const meta = (resource as any).meta as { moduleName: string }
+  if (!meta) throw new Error("No meta defined in Resource!")
+  return meta as M["meta"]
+}
 
-      return (typedKeysOf(filtered)
-        .reduce((prev, cur) => {
-          const h = filtered[cur]!
+export const makeRpcGroup = <M extends Requests>(resource: M) => {
+  const filtered = getFiltered(resource)
+  type newM = typeof filtered
 
-          const Request = h
-          const Response = h.success
+  const rpcs = RpcGroup.make(
+    ...typedValuesOf(filtered).map((_) => {
+      return Rpc.fromTaggedRequest(_ as any)
+    })
+  ) as RpcGroup.RpcGroup<RpcHandlers<newM>[keyof newM]>
+  return rpcs
+}
 
-          const requestName = `${meta.moduleName}.${cur as string}`
-            .replaceAll(".js", "")
+const makeRpcTag = <M extends Requests>(resource: M) => {
+  const rpcs = makeRpcGroup(resource)
+  const meta = getMeta(resource)
 
-          const requestMeta = {
-            Request,
-            name: requestName
-          }
+  return class TheClient extends Context.Tag(`RpcClient.${meta.moduleName}`)<
+    TheClient,
+    RpcClient.RpcClient<RpcGroup.Rpcs<typeof rpcs>>
+  >() {
+    static layer = Layer.scoped(TheClient, RpcClient.make(rpcs))
+  }
+}
 
-          const client: <Req extends Schema.TaggedRequest.All>(request: Req) => Rpc.Rpc.Result<Req, unknown> =
-            baseClient
+const makeApiClientFactory = Effect
+  .gen(function*() {
+    const ctx = yield* Effect.context<RpcSerialization.RpcSerialization | HttpClient.HttpClient>()
+    const makeClientFor = <M extends Requests>(resource: M, requestLevelLayers = Layer.empty) =>
+      Effect.gen(function*() {
+        const TheClient = makeRpcTag(resource)
+
+        const meta = getMeta(resource)
+
+        // TODO: somehow we need a protocol per REQUEST kind of it seems ...
+        // otherwise it locks up on the client, navigation remains empty...
+        const clientLayer = TheClient.layer.pipe(
+          // add ApiClientFactory for nested schemas
+          // eslint-disable-next-line @typescript-eslint/no-use-before-define
+          Layer.provide(Layer.succeed(ApiClientFactory, makeClientForCached as any)),
+          Layer.provide(
+            RpcClient
+              .layerProtocolHttp({
+                url: "" // why not here set meta.moduleName as root?
+              })
               .pipe(
-                HttpClient.mapRequest(HttpClientRequest.appendUrlParam("action", cur as string)),
-                resolver
+                Layer.provideMerge(Layer.succeedContext(ctx))
               )
+          )
+        )
+        const mr = ManagedRuntime.make(clientLayer)
+
+        const filtered = getFiltered(resource)
+        return {
+          mr,
+          client: (typedKeysOf(filtered)
+            .reduce((prev, cur) => {
+              const h = filtered[cur]!
+
+              const Request = h
+              const Response = h.success
 
-          const fields = Struct.omit(Request.fields, "_tag")
-          // @ts-expect-error doc
-          prev[cur] = Object.keys(fields).length === 0
-            ? {
-              handler: client(new Request() as Schema.TaggedRequest.All).pipe(
-                Effect.withSpan("client.request " + requestName, {
-                  captureStackTrace: false,
-                  attributes: { "request.name": requestName }
-                }),
-                Effect.provide(requestLevelLayers)
-              ),
-              ...requestMeta,
-              raw: {
-                handler: client(new Request() as Schema.TaggedRequest.All).pipe(
-                  Effect.flatMap((res) => S.encode(Response)(res)), // TODO,
-                  Effect.withSpan("client.request " + requestName, {
-                    captureStackTrace: false,
-                    attributes: { "request.name": requestName }
-                  }),
-                  Effect.provide(requestLevelLayers)
-                ),
-                ...requestMeta
+              const requestName = `${meta.moduleName}.${cur as string}`
+                .replaceAll(".js", "")
+
+              const requestMeta = {
+                Request,
+                name: requestName
               }
-            }
-            : {
-              handler: (req: any) =>
-                client(new Request(req) as Schema.TaggedRequest.All).pipe(
-                  Effect.withSpan("client.request " + requestName, {
-                    captureStackTrace: false,
-                    attributes: { "request.name": requestName }
-                  }),
-                  Effect.provide(requestLevelLayers)
-                ),
-
-              ...requestMeta,
-              raw: {
-                handler: (req: any) =>
-                  client(new Request(req) as Schema.TaggedRequest.All).pipe(
-                    Effect.flatMap((res) => S.encode(Response)(res)), // TODO,
+
+              const requestNameLayer = Layer.succeed(RequestName, {
+                requestName: cur as string,
+                moduleName: meta.moduleName
+              })
+
+              const fields = Struct.omit(Request.fields, "_tag")
+              const requestAttr = h._tag
+              // @ts-expect-error doc
+              prev[cur] = Object.keys(fields).length === 0
+                ? {
+                  handler: TheClient.pipe(
+                    Effect.flatMap((client) => (client as any)[requestAttr]!(new Request()) as Effect<any, any, never>),
                     Effect.withSpan("client.request " + requestName, {
                       captureStackTrace: false,
                       attributes: { "request.name": requestName }
                     }),
-                    Effect.provide(requestLevelLayers)
+                    Effect.provide(requestLevelLayers),
+                    Effect.provide(mr),
+                    Effect.provide(requestNameLayer)
                   ),
+                  ...requestMeta,
+                  raw: {
+                    handler: TheClient.pipe(
+                      Effect.flatMap((client) =>
+                        (client as any)[requestAttr]!(new Request()) as Effect<any, any, never>
+                      ),
+                      Effect.flatMap((res) => S.encode(Response)(res)), // TODO,
+                      Effect.withSpan("client.request " + requestName, {
+                        captureStackTrace: false,
+                        attributes: { "request.name": requestName }
+                      }),
+                      Effect.provide(requestLevelLayers),
+                      Effect.provide(mr),
+                      Effect.provide(requestNameLayer)
+                    ),
 
-                ...requestMeta
-              }
-            }
+                    ...requestMeta
+                  }
+                }
+                : {
+                  handler: (req: any) =>
+                    TheClient.pipe(
+                      Effect.flatMap((client) =>
+                        (client as any)[requestAttr]!(new Request(req)) as Effect<any, any, never>
+                      ),
+                      Effect.withSpan("client.request " + requestName, {
+                        captureStackTrace: false,
+                        attributes: { "request.name": requestName }
+                      }),
+                      Effect.provide(requestLevelLayers),
+                      Effect.provide(mr),
+                      Effect.provide(requestNameLayer)
+                    ),
 
-          return prev
-        }, {} as Client<M>))
-    }
+                  ...requestMeta,
+                  raw: {
+                    handler: (req: any) =>
+                      TheClient.pipe(
+                        Effect.flatMap((client) =>
+                          (client as any)[requestAttr]!(new Request(req)) as Effect<any, any, never>
+                        ),
+                        Effect.flatMap((res) => S.encode(Response)(res)), // TODO,
+                        Effect.withSpan("client.request " + requestName, {
+                          captureStackTrace: false,
+                          attributes: { "request.name": requestName }
+                        }),
+                        Effect.provide(requestLevelLayers),
+                        Effect.provide(mr),
+                        Effect.provide(requestNameLayer)
+                      ),
+
+                    ...requestMeta
+                  }
+                }
+
+              return prev
+            }, {} as Client<M>))
+        }
+      })
+
+    const register: ManagedRuntime.ManagedRuntime<any, any>[] = []
+    yield* Effect.addFinalizer(() => Effect.forEach(register, (mr) => mr.disposeEffect))
+
+    const cacheL = new Map<any, Map<any, Client<any>>>()
 
     function makeClientForCached(requestLevelLayers: Layer.Layer<never, never, never>) {
-      const cache = new Map<any, Client<any>>()
+      let cache = cacheL.get(requestLevelLayers)
+      if (!cache) {
+        cache = new Map<any, Client<any>>()
+        cacheL.set(requestLevelLayers, cache)
+      }
 
       return <M extends Requests>(
         models: M
-      ): Client<Omit<M, "meta">> => {
-        const found = cache.get(models)
-        if (found) {
-          return found
-        }
-        const m = makeClientFor(models, requestLevelLayers)
-        cache.set(models, m)
-        return m
-      }
+      ): Effect<Client<Omit<M, "meta">>> =>
+        Effect.gen(function*() {
+          const found = cache.get(models)
+          if (found) {
+            return found
+          }
+          const m = yield* makeClientFor(models, requestLevelLayers)
+          cache.set(models, m.client)
+          register.push(m.mr)
+          return m.client
+        })
     }
 
     return makeClientForCached
@@ -201,14 +272,15 @@ const makeApiClientFactory = (config: ApiConfig) =>
  * Used to create clients for resource modules.
  */
 export class ApiClientFactory
-  extends Context.TagId("ApiClientFactory")<ApiClientFactory, Effect.Success<ReturnType<typeof makeApiClientFactory>>>()
+  extends Context.TagId("ApiClientFactory")<ApiClientFactory, Effect.Success<typeof makeApiClientFactory>>()
 {
-  static readonly layer = (config: ApiConfig) => this.toLayer(makeApiClientFactory(config))
+  static readonly layer = (config: ApiConfig) =>
+    this.toLayerScoped(makeApiClientFactory).pipe(Layer.provide(makeProtocol(config)))
   static readonly layerFromConfig = DefaultApiConfig.pipe(Effect.map(this.layer), Layer.unwrapEffect)
 
   static readonly makeFor =
     (requestLevelLayers: Layer.Layer<never, never, never>) => <M extends Requests>(resource: M) =>
       this
         .use((apiClientFactory) => apiClientFactory(requestLevelLayers))
-        .pipe(Effect.map((f) => f(resource))) // don't rename f to clientFor or integration in vue project linked fucks up
+        .pipe(Effect.flatMap((f) => f(resource))) // don't rename f to clientFor or integration in vue project linked fucks up
 }

package/src/client/clientFor.ts

@@ -4,8 +4,7 @@
 import type * as Request from "effect/Request"
 import type { Path } from "path-parser"
 import qs from "query-string"
-import type { Effect, Schema } from "../internal/lib.js"
-import { Record } from "../internal/lib.js"
+import { type Effect, Record, type Schema } from "../internal/lib.js"
 import type * as S from "../Schema.js"
 
 export function makePathWithQuery(

package/src/ids.ts

@@ -1,5 +1,4 @@
-import { brandedStringId, NonEmptyString255, StringId, withDefaultMake } from "effect-app/Schema"
-import type { Schema, StringIdBrand } from "effect-app/Schema"
+import { brandedStringId, NonEmptyString255, type Schema, StringId, type StringIdBrand, withDefaultMake } from "effect-app/Schema"
 import type { B } from "effect-app/Schema/schema"
 import type { Simplify } from "effect/Types"
 import { S } from "./index.js"
@@ -13,7 +12,6 @@ export type RequestId = NonEmptyString255
 // a request id may be made from a span id, which does not comply with StringId schema.
 export const RequestId = extendM(
   Object
-    // eslint-disable-next-line @typescript-eslint/ban-types
     .assign(Object.create(NonEmptyString255) as {}, NonEmptyString255 as Schema<NonEmptyString255, string>),
   (s) => {
     const make = StringId.make as () => NonEmptyString255

package/src/internal/lib.ts

@@ -5,28 +5,7 @@ export * as Utils from "../utils.js"
 // for app land, it may make sense to create an app/prelude?
 export * from "./Prelude.js"
 
-export {
-  Array,
-  Cause,
-  Chunk,
-  Config,
-  Context,
-  Duration,
-  Effect,
-  Either,
-  Equal,
-  Equivalence,
-  Exit,
-  FiberRef,
-  HashMap,
-  Layer,
-  Option,
-  Order,
-  Record,
-  Ref,
-  Schema,
-  Scope
-} from "./Prelude.js"
+export { Array, Cause, Chunk, Config, Context, Duration, Effect, Either, Equal, Equivalence, Exit, FiberRef, HashMap, Layer, Option, Order, Record, Ref, Schema, Scope } from "./Prelude.js"
 
 export * as Struct from "../Struct.js"
 export type * as Types from "../Types.js"

package/src/utils/effectify.ts

@@ -242,6 +242,7 @@ export const effectify: {
     onSyncError: (error: unknown, args: Parameters<F>) => E2
   ): Effectify<F, E | E2>
 } =
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
   (<A>(fn: Function, onError?: (e: any, args: any) => any, onSyncError?: (e: any, args: any) => any) =>
   (...args: Array<any>) =>
     Effect.async<A, Error>((resume) => {

package/src/utils/logger.ts

@@ -1,8 +1,7 @@
 /* eslint-disable @typescript-eslint/no-unsafe-argument */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
-import type { LogLevel } from "effect"
-import { Context, Effect } from "effect"
+import { Context, Effect, type LogLevel } from "effect"
 
 type Levels = "info" | "debug" | "warn" | "error"
 

package/src/utils.ts

@@ -1,4 +1,6 @@
+/* eslint-disable @typescript-eslint/no-unsafe-function-type */
 /* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-redundant-type-constituents */
 import { Effect, Option, Record } from "effect"
 import * as Either from "effect/Either"
 import { dual, isFunction } from "effect/Function"

package/src/validation/validators.ts

@@ -1,6 +1,5 @@
 // Not importing from /es/lib because they are .js files and bundlers probably assume they're cjs :(
-import type { IsEmailOptions } from "validator/lib/isEmail.js"
-import isEmail from "validator/lib/isEmail.js"
+import isEmail, { type IsEmailOptions } from "validator/lib/isEmail.js"
 
 // Source https://emailregex.com/
 // eslint-disable-next-line no-control-regex

package/.eslintrc.cjs

@@ -1,11 +0,0 @@
-const makeBase = require("../../.eslintrc.base")
-const base = makeBase(__dirname, true)
-
-module.exports = {
-  ...base,
-  rules: {
-    ...base.rules,
-    'codegen/codegen': ['error', { presets: require('@effect-app/eslint-codegen-model') }],
-    "@typescript-eslint/no-empty-interface": "off"
-  }
-}