@effect-app/infra 1.38.0 → 1.40.0

package/src/api/routing2.ts

@@ -177,21 +177,32 @@ export interface ExtendedMiddleware<Context, CTXMap extends Record<string, RPCCo
 }
 
 export const RouterSymbol = Symbol()
-export interface RouterS<Rsc> {
+export interface RouterShape<Rsc> {
   [RouterSymbol]: Rsc
 }
 
+type RPCRouteR<T extends Rpc.Rpc<any, any>> = [T] extends [
+  Rpc.Rpc<any, infer R>
+] ? R
+  : never
+
+type RPCRouteReq<T extends Rpc.Rpc<any, any>> = [T] extends [
+  Rpc.Rpc<infer Req, any>
+] ? Req
+  : never
+
 export const makeRouter = <Context, CTXMap extends Record<string, RPCContextMap.Any>>(
   middleware: ExtendedMiddleware<Context, CTXMap>,
   devMode: boolean
 ) => {
   const rpc = makeRpc(middleware)
-  function matchFor<Rsc extends Record<string, any> & { meta: { moduleName: string } }>(
-    rsc: Rsc
+  function matchFor<
+    const ModuleName extends string,
+    const Rsc extends Record<string, any>
+  >(
+    rsc: Rsc & { meta: { moduleName: ModuleName } }
   ) {
-    const meta = (rsc as any).meta as { moduleName: string }
-    if (!meta) throw new Error("Resource has no meta specified") // TODO: do something with moduleName+cur etc.
-
+    const meta = rsc.meta
     type Filtered = Filter<Rsc>
     const filtered = typedKeysOf(rsc).reduce((acc, cur) => {
       if (Predicate.isObject(rsc[cur]) && rsc[cur]["success"]) {
@@ -388,25 +399,15 @@ export const makeRouter = <Context, CTXMap extends Record<string, RPCContextMap.
         >
       }
 
-      type RPCRouteR<T extends Rpc.Rpc<any, any>> = [T] extends [
-        Rpc.Rpc<any, infer R>
-      ] ? R
-        : never
-
-      type RPCRouteReq<T extends Rpc.Rpc<any, any>> = [T] extends [
-        Rpc.Rpc<infer Req, any>
-      ] ? Req
-        : never
-
       const rpcRouter = RpcRouter.make(...Object.values(mapped) as any) as RpcRouter.RpcRouter<
         RPCRouteReq<typeof mapped[keyof typeof mapped]>,
         RPCRouteR<typeof mapped[keyof typeof mapped]>
       >
 
-      type Router = RouterS<Rsc>
+      type Router = RouterShape<Rsc>
       const r: HttpRouter.HttpRouter.TagClass<
         Router,
-        string,
+        `${typeof meta.moduleName}Router`,
         never,
         Exclude<
           RPCRouteR<
@@ -414,7 +415,7 @@ export const makeRouter = <Context, CTXMap extends Record<string, RPCContextMap.
           >,
           { [k in keyof TLayers]: Layer.Layer.Success<TLayers[k]> }[number]
         >
-      > = (class Router extends HttpRouter.Tag(meta.moduleName + "Router")<Router>() {}) as any
+      > = (class Router extends HttpRouter.Tag(`${meta.moduleName}Router`)<Router>() {}) as any
 
       const layer = r.use((router) =>
         Effect.gen(function*() {
@@ -456,7 +457,165 @@ export const makeRouter = <Context, CTXMap extends Record<string, RPCContextMap.
       }
     }
 
+    const effect = <
+      E,
+      R,
+      THandlers extends {
+        // import to keep them separate via | for type checking!!
+        [K in Keys]: AHandler<Rsc[K]>
+      },
+      TLayers extends NonEmptyArray<Layer.Layer.Any>
+    >(
+      layers: TLayers,
+      make: Effect<THandlers, E, R>
+    ) => {
+      type Router = RouterShape<Rsc>
+      const r: HttpRouter.HttpRouter.TagClass<
+        Router,
+        `${typeof meta.moduleName}Router`,
+        never,
+        Exclude<
+          RPCRouteR<
+            { [K in keyof Filter<Rsc>]: Rpc.Rpc<Rsc[K], _R<ReturnType<THandlers[K]["handler"]>>> }[keyof Filter<Rsc>]
+          >,
+          { [k in keyof TLayers]: Layer.Layer.Success<TLayers[k]> }[number]
+        >
+      > = (class Router extends HttpRouter.Tag(`${meta.moduleName}Router`)<Router>() {}) as any
+
+      const layer = r.use((router) =>
+        Effect.gen(function*() {
+          const controllers = yield* make
+          // return make.pipe(Effect.map((c) => controllers(c, layers)))
+          const mapped = typedKeysOf(filtered).reduce((acc, cur) => {
+            const handler = controllers[cur as keyof typeof controllers]
+            const req = rsc[cur]
+
+            acc[cur] = rpc.effect(
+              handler._tag === "raw"
+                ? class extends (req as any) {
+                  static success = S.encodedSchema(req.success)
+                  get [Serializable.symbol]() {
+                    return this.constructor
+                  }
+                  get [Serializable.symbolResult]() {
+                    return {
+                      failure: req.failure,
+                      success: S.encodedSchema(req.success)
+                    }
+                  }
+                } as any
+                : req,
+              (req) =>
+                Effect
+                  .annotateCurrentSpan(
+                    "requestInput",
+                    Object.entries(req).reduce((prev, [key, value]: [string, unknown]) => {
+                      prev[key] = key === "password"
+                        ? "<redacted>"
+                        : typeof value === "string" || typeof value === "number" || typeof value === "boolean"
+                        ? typeof value === "string" && value.length > 256
+                          ? (value.substring(0, 253) + "...")
+                          : value
+                        : Array.isArray(value)
+                        ? `Array[${value.length}]`
+                        : value === null || value === undefined
+                        ? `${value}`
+                        : typeof value === "object" && value
+                        ? `Object[${Object.keys(value).length}]`
+                        : typeof value
+                      return prev
+                    }, {} as Record<string, string | number | boolean>)
+                  )
+                  .pipe(
+                    // can't use andThen due to some being a function and effect
+                    Effect.zipRight(handler.handler(req as any) as any),
+                    Effect.tapErrorCause((cause) => Cause.isFailure(cause) ? logRequestError(cause) : Effect.void),
+                    Effect.tapDefect((cause) =>
+                      Effect
+                        .all([
+                          reportRequestError(cause, {
+                            action: `${meta.moduleName}.${req._tag}`
+                          }),
+                          Rpc.currentHeaders.pipe(Effect.andThen((headers) => {
+                            return InfraLogger
+                              .logError("Finished request", cause)
+                              .pipe(Effect.annotateLogs({
+                                action: `${meta.moduleName}.${req._tag}`,
+                                req: pretty(req),
+                                headers: pretty(headers)
+                                // resHeaders: pretty(
+                                //   Object
+                                //     .entries(headers)
+                                //     .reduce((prev, [key, value]) => {
+                                //       prev[key] = value && typeof value === "string" ? snipString(value) : value
+                                //       return prev
+                                //     }, {} as Record<string, any>)
+                                // )
+                              }))
+                          }))
+                        ])
+                    ),
+                    devMode ? (_) => _ : Effect.catchAllDefect(() => Effect.die("Internal Server Error")),
+                    Effect.withSpan("Request." + meta.moduleName + "." + req._tag, {
+                      captureStackTrace: () => handler.stack
+                    })
+                  ),
+              meta.moduleName
+            ) // TODO
+            return acc
+          }, {} as any) as {
+            [K in Keys]: Rpc.Rpc<
+              Rsc[K],
+              _R<ReturnType<THandlers[K]["handler"]>>
+            >
+          }
+
+          const rpcRouter = RpcRouter.make(...Object.values(mapped) as any) as RpcRouter.RpcRouter<
+            RPCRouteReq<typeof mapped[keyof typeof mapped]>,
+            RPCRouteR<typeof mapped[keyof typeof mapped]>
+          >
+          const httpApp = toHttpApp(rpcRouter, {
+            spanPrefix: rsc
+              .meta
+              .moduleName + "."
+          })
+          const services = (yield* Effect.context<never>()).pipe(
+            Context.omit(Scope.Scope as never),
+            Context.omit(Tracer.ParentSpan as never)
+          )
+          yield* router
+            .all(
+              "/",
+              (httpApp
+                .pipe(HttpMiddleware.make(Effect.provide(services)))) as any,
+              // TODO: not queries.
+              { uninterruptible: true }
+            )
+        })
+      )
+
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+      const routes = layer.pipe(
+        Layer.provideMerge(r.Live),
+        layers ? Layer.provide(layers) as any : (_) => _
+      ) as Layer.Layer<
+        Router,
+        { [k in keyof TLayers]: Layer.Layer.Error<TLayers[k]> }[number] | E,
+        | { [k in keyof TLayers]: Layer.Layer.Context<TLayers[k]> }[number]
+        | Exclude<R, { [k in keyof TLayers]: Layer.Layer.Success<TLayers[k]> }[number]>
+      >
+
+      // Effect.Effect<HttpRouter.HttpRouter<unknown, HttpRouter.HttpRouter.DefaultServices>, never, UserRouter>
+
+      return {
+        moduleName: meta.moduleName,
+        Router: r,
+        routes
+      }
+    }
+
     const r = {
+      effect,
       controllers,
       ...typedKeysOf(filtered).reduce(
         (prev, cur) => {

package/src/services/Operations.ts

@@ -1,6 +1,6 @@
-import { annotateLogscoped, flatMap } from "@effect-app/core/Effect"
+import { annotateLogscoped } from "@effect-app/core/Effect"
 import { dual, pipe } from "@effect-app/core/Function"
-import type { RequestFiberSet } from "@effect-app/infra-adapters/RequestFiberSet"
+import { RequestFiberSet } from "@effect-app/infra-adapters/RequestFiberSet"
 import { reportError } from "@effect-app/infra/errorReporter"
 import { NonEmptyString2k } from "@effect-app/schema"
 import { subHours } from "date-fns"
@@ -19,8 +19,19 @@ const reportAppError = reportError("Operations.Cleanup")
 
 const make = Effect.gen(function*() {
   const repo = yield* OperationsRepo
+  const reqFiberSet = yield* RequestFiberSet
   const makeOp = Effect.sync(() => OperationId.make())
 
+  const register = (title: NonEmptyString2k) =>
+    Effect.tap(
+      makeOp,
+      (id) =>
+        Effect.andThen(
+          annotateLogscoped("operationId", id),
+          Effect.acquireRelease(addOp(id, title), (_, exit) => finishOp(id, exit))
+        )
+    )
+
   const cleanup = Effect.sync(() => subHours(new Date(), 1)).pipe(
     Effect.andThen((before) => repo.query(where("updatedAt", "lt", before.toISOString()))),
     Effect.andThen((ops) => pipe(ops, batch(100, Effect.succeed, (items) => repo.removeAndPublish(items)))),
@@ -68,18 +79,75 @@ const make = Effect.gen(function*() {
       (_) => repo.save(copy(_, { updatedAt: new Date(), progress })).pipe(Effect.orDie)
     )
   }
+
+  function fork<R, R2, E, E2, A, A2>(
+    self: (id: OperationId) => Effect<A, E, R>,
+    fnc: (id: OperationId) => Effect<A2, E2, R2>,
+    title: NonEmptyString2k
+  ): Effect<
+    RunningOperation<A, E>,
+    never,
+    Exclude<R, Scope.Scope> | Exclude<R2, Scope.Scope>
+  > {
+    return Effect
+      .flatMap(
+        Scope.make(),
+        (scope) =>
+          register(title)
+            .pipe(
+              Scope.extend(scope),
+              Effect.flatMap((id) =>
+                forkDaemonReportRequestUnexpected(Scope.use(
+                  self(id).pipe(Effect.withSpan(title)),
+                  scope
+                ))
+                  .pipe(Effect.map((fiber): RunningOperation<A, E> => ({ fiber, id })))
+              ),
+              Effect.tap(({ id }) =>
+                Effect.interruptible(fnc(id)).pipe(
+                  Effect.forkScoped,
+                  Scope.extend(scope)
+                )
+              )
+            )
+      )
+      .pipe(Effect.provideService(RequestFiberSet, reqFiberSet))
+  }
+
+  const fork2: {
+    (title: NonEmptyString2k): <R, E, A>(
+      self: (opId: OperationId) => Effect<A, E, R>
+    ) => Effect<RunningOperation<A, E>, never, Exclude<R, Scope.Scope>>
+    <R, E, A>(
+      self: (opId: OperationId) => Effect<A, E, R>,
+      title: NonEmptyString2k
+    ): Effect<RunningOperation<A, E>, never, Exclude<R, Scope.Scope>>
+  } = dual(
+    2,
+    <R, E, A>(self: (opId: OperationId) => Effect<A, E, R>, title: NonEmptyString2k) =>
+      Effect.flatMap(
+        Scope.make(),
+        (scope) =>
+          register(title)
+            .pipe(
+              Scope.extend(scope),
+              Effect
+                .flatMap((id) =>
+                  forkDaemonReportRequestUnexpected(Scope.use(
+                    self(id).pipe(Effect.withSpan(title)),
+                    scope
+                  ))
+                    .pipe(Effect.map((fiber): RunningOperation<A, E> => ({ fiber, id })))
+                )
+            )
+      )
+  )
+
   return {
     cleanup,
-    register: (title: NonEmptyString2k) =>
-      Effect.tap(
-        makeOp,
-        (id) =>
-          Effect.andThen(
-            annotateLogscoped("operationId", id),
-            Effect.acquireRelease(addOp(id, title), (_, exit) => finishOp(id, exit))
-          )
-      ),
-
+    register,
+    fork,
+    fork2,
     all: repo.all,
     find: findOp,
     update
@@ -106,7 +174,7 @@ export class Operations extends Context.TagMakeId("effect-app/Operations", make)
     )
     .pipe(Layer.effectDiscard, Layer.provide(MainFiberSet.Live))
 
-  static readonly Live = this.CleanupLive.pipe(Layer.provideMerge(this.toLayer()))
+  static readonly Live = this.CleanupLive.pipe(Layer.provideMerge(this.toLayer()), Layer.provide(RequestFiberSet.Live))
 }
 
 export interface RunningOperation<A, E> {
@@ -147,68 +215,3 @@ export const forkOperation: {
 export function forkOperationFunction<R, E, A, Inp>(fnc: (inp: Inp) => Effect<A, E, R>, title: NonEmptyString2k) {
   return (inp: Inp) => fnc(inp).pipe((_) => forkOperation(_, title))
 }
-
-export const forkOperation2: {
-  (title: NonEmptyString2k): <R, E, A>(
-    self: (opId: OperationId) => Effect<A, E, R>
-  ) => Effect<RunningOperation<A, E>, never, Operations | Exclude<R, Scope.Scope>>
-  <R, E, A>(
-    self: (opId: OperationId) => Effect<A, E, R>,
-    title: NonEmptyString2k
-  ): Effect<RunningOperation<A, E>, never, Operations | Exclude<R, Scope.Scope>>
-} = dual(
-  2,
-  <R, E, A>(self: (opId: OperationId) => Effect<A, E, R>, title: NonEmptyString2k) =>
-    flatMap(Operations, (Operations) =>
-      Effect.flatMap(
-        Scope.make(),
-        (scope) =>
-          Operations
-            .register(title)
-            .pipe(
-              Scope.extend(scope),
-              Effect
-                .flatMap((id) =>
-                  forkDaemonReportRequestUnexpected(Scope.use(
-                    self(id).pipe(Effect.withSpan(title)),
-                    scope
-                  ))
-                    .pipe(Effect.map((fiber): RunningOperation<A, E> => ({ fiber, id })))
-                )
-            )
-      ))
-)
-
-export function forkOperationWithEffect<R, R2, E, E2, A, A2>(
-  self: (id: OperationId) => Effect<A, E, R>,
-  fnc: (id: OperationId) => Effect<A2, E2, R2>,
-  title: NonEmptyString2k
-): Effect<
-  RunningOperation<A, E>,
-  never,
-  Operations | RequestFiberSet | Exclude<R, Scope.Scope> | Exclude<R2, Scope.Scope>
-> {
-  return Effect.flatMap(Operations, (Operations) =>
-    Effect.flatMap(
-      Scope.make(),
-      (scope) =>
-        Operations
-          .register(title)
-          .pipe(
-            Scope.extend(scope),
-            Effect.flatMap((id) =>
-              forkDaemonReportRequestUnexpected(Scope.use(
-                self(id).pipe(Effect.withSpan(title)),
-                scope
-              ))
-                .pipe(Effect.map((fiber): RunningOperation<A, E> => ({ fiber, id })))
-            ),
-            Effect.tap(({ id }) =>
-              Effect.interruptible(fnc(id)).pipe(
-                Effect.forkScoped,
-                Scope.extend(scope)
-              )
-            )
-          )
-    ))
-}