@effect-app/infra 2.90.0 → 2.91.0

package/src/api/routing.ts

@@ -2,9 +2,8 @@
 /* eslint-disable @typescript-eslint/no-unsafe-argument */
 /* eslint-disable @typescript-eslint/no-empty-object-type */
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { determineMethod, isCommand } from "@effect-app/infra/api/routing/utils"
 import { Rpc, RpcGroup, RpcServer } from "@effect/rpc"
-import { type Array, Effect, Layer, type NonEmptyReadonlyArray, Predicate, S, Schedule, Schema, type Scope } from "effect-app"
+import { type Array, Effect, Layer, type NonEmptyReadonlyArray, Predicate, S, Schema, type Scope } from "effect-app"
 import type { GetEffectContext, GetEffectError, RPCContextMap } from "effect-app/client/req"
 import { type HttpHeaders, HttpRouter } from "effect-app/http"
 import { typedKeysOf, typedValuesOf } from "effect-app/utils"
@@ -16,11 +15,6 @@ import { DevMode, type RouterMiddleware } from "./routing/middleware.js"
 
 export * from "./routing/middleware.js"
 
-// retry just once on optimistic concurrency exceptions
-const optimisticConcurrencySchedule = Schedule.once.pipe(
-  Schedule.intersect(Schedule.recurWhile<any>((a) => a?._tag === "OptimisticConcurrencyException"))
-)
-
 // it's the result of extending S.Req setting success, config
 // it's a schema plus some metadata
 export type AnyRequestModule = S.Schema.Any & {
@@ -55,8 +49,8 @@ export interface AddAction<Actions extends AnyRequestModule, Accum extends Recor
 namespace RequestTypes {
   export const DECODED = "d" as const
   export type DECODED = typeof DECODED
-  export const TYPE = "raw" as const
-  export type TYPE = typeof TYPE
+  export const RAW = "raw" as const
+  export type RAW = typeof RAW
 }
 type RequestType = typeof RequestTypes[keyof typeof RequestTypes]
 
@@ -157,7 +151,7 @@ export type RouteMatcher<
       /**
        * Requires the Encoded shape (e.g directly undecoded from DB, so that we don't do multiple Decode/Encode)
        */
-      raw: Match<Resource, RequestContextMap, RequestTypes.TYPE, Key>
+      raw: Match<Resource, RequestContextMap, RequestTypes.RAW, Key>
     }
 }
 
@@ -238,9 +232,9 @@ export const makeRouter = <
     type HandlersDecoded<Action extends AnyRequestModule> = Handlers<Action, RequestTypes.DECODED>
 
     type HandlersRaw<Action extends AnyRequestModule> =
-      | { raw: HandlerWithInputGen<Action, RequestTypes.TYPE> }
-      | { raw: HandlerWithInputEff<Action, RequestTypes.TYPE> }
-      | { raw: HandlerEff<Action, RequestTypes.TYPE> }
+      | { raw: HandlerWithInputGen<Action, RequestTypes.RAW> }
+      | { raw: HandlerWithInputEff<Action, RequestTypes.RAW> }
+      | { raw: HandlerEff<Action, RequestTypes.RAW> }
 
     type AnyHandlers<Action extends AnyRequestModule> = HandlersRaw<Action> | HandlersDecoded<Action>
 
@@ -287,13 +281,13 @@ export const makeRouter = <
                 ? class {
                   static request = rsc[cur]
                   static stack = stack
-                  static _tag = RequestTypes.TYPE
+                  static _tag = RequestTypes.RAW
                   static handler = () => handlerImpl
                 }
                 : class {
                   static request = rsc[cur]
                   static stack = stack
-                  static _tag = RequestTypes.TYPE
+                  static _tag = RequestTypes.RAW
                   static handler = handlerImpl
                 }
             }
@@ -303,16 +297,6 @@ export const makeRouter = <
       {} as RouteMatcher<RequestContextMap, Resource>
     )
 
-    const router: AddAction<RequestModules[keyof RequestModules]> = {
-      accum: {},
-      add(a: any) {
-        ;(this.accum as any)[a.request._tag] = a
-        ;(this as any)[a.request._tag] = a
-        if (Object.keys(this.accum).length === Object.keys(requestModules).length) return this.accum as any
-        return this as any
-      }
-    }
-
     const router3: <
       const Impl extends {
         [K in keyof FilterRequestModules<Resource>]: AnyHandlers<Resource[K]>
@@ -322,7 +306,7 @@ export const makeRouter = <
     ) => {
       [K in keyof Impl & keyof FilterRequestModules<Resource>]: Handler<
         FilterRequestModules<Resource>[K],
-        Impl[K] extends { raw: any } ? RequestTypes.TYPE : RequestTypes.DECODED,
+        Impl[K] extends { raw: any } ? RequestTypes.RAW : RequestTypes.DECODED,
         Exclude<
           Exclude<
             // retrieves context R from the actual implementation of the handler
@@ -358,38 +342,32 @@ export const makeRouter = <
       MakeE,
       MakeR,
       THandlers extends {
-        // import to keep them separate via | for type checking!!
+        // important to keep them separate via | for type checking!!
         [K in keyof RequestModules]: AnyHandler<Resource[K]>
       },
       MakeDependencies extends NonEmptyReadonlyArray<Layer.Layer.Any> | never[]
     >(
       dependencies: MakeDependencies,
-      make: Effect<THandlers, MakeE, MakeR> | Generator<YieldWrap<Effect<any, MakeE, MakeR>>, THandlers, any>
+      make: (
+        match: any
+      ) => Effect<THandlers, MakeE, MakeR> | Generator<YieldWrap<Effect<any, MakeE, MakeR>>, THandlers, any>
     ) => {
       type Router = RouterShape<Resource>
       const layer = Effect
         .gen(function*() {
-          make = (make as any)[Symbol.toStringTag] === "GeneratorFunction"
+          const finalMake = ((make as any)[Symbol.toStringTag] === "GeneratorFunction"
             ? Effect.fnUntraced(make as any)(router3) as any
-            : make
+            : make(router3) as any) as Effect<THandlers, MakeE, MakeR>
 
-          const controllers = yield* make
+          const controllers = yield* finalMake
 
           // return make.pipe(Effect.map((c) => controllers(c, dependencies)))
           const mapped = typedKeysOf(requestModules).reduce((acc, cur) => {
             const handler = controllers[cur as keyof typeof controllers]
             const resource = rsc[cur]
 
-            const method = determineMethod(String(cur), resource)
-
-            const handle = isCommand(method)
-              ? (req: S.Schema.Type<AnyRequestModule>, headers: HttpHeaders.Headers) =>
-                Effect.retry(handler.handler(req, headers) as any, optimisticConcurrencySchedule)
-              : (req: S.Schema.Type<AnyRequestModule>, headers: HttpHeaders.Headers) =>
-                Effect.interruptible(handler.handler(req, headers) as any)
-
             acc[cur] = [
-              handler._tag === RequestTypes.TYPE
+              handler._tag === RequestTypes.RAW
                 ? class extends (resource as any) {
                   static success = S.encodedSchema(resource.success)
                   get [Schema.symbolSerializable]() {
@@ -404,12 +382,11 @@ export const makeRouter = <
                 } as any
                 : resource,
               (payload: any, headers: any) =>
-                handle(payload, headers).pipe(
+                (handler.handler(payload, headers) as Effect<unknown, unknown, unknown>).pipe(
                   Effect.withSpan("Request." + resource._tag, {
                     captureStackTrace: () => handler.stack // capturing the handler stack is the main reason why we are doing the span here
                   })
-                ),
-              meta.moduleName
+                )
             ] as const
             return acc
           }, {} as any) as {
@@ -502,16 +479,12 @@ export const makeRouter = <
               Effect<
                 any,
                 any,
-                Make["strict"] extends false ? any
-                  : Make extends { dependencies: Array<Layer.Layer.Any> } ? MakeDepsOut<Make>
-                  : any
+                any
               >
             >,
             { [K in keyof FilterRequestModules<Resource>]: AnyHandler<Resource[K]> },
             any
           >
-
-          strict?: boolean
           /** @deprecated */
           readonly ಠ_ಠ: never
         }
@@ -539,14 +512,11 @@ export const makeRouter = <
       <
         const Make extends {
           dependencies?: Array<Layer.Layer.Any>
-          effect: Effect<
+          effect: (match: typeof router3) => Effect<
             { [K in keyof FilterRequestModules<Resource>]: AnyHandler<Resource[K]> },
             any,
-            Make["strict"] extends false ? any
-              : Make extends { dependencies: Array<Layer.Layer.Any> } ? MakeDepsOut<Make>
-              : any
+            any
           >
-          strict?: boolean
           /** @deprecated */
           readonly ಠ_ಠ: never
         }
@@ -574,12 +544,11 @@ export const makeRouter = <
       <
         const Make extends {
           dependencies?: Array<Layer.Layer.Any>
-          effect: Effect<
+          effect: (match: typeof router3) => Effect<
             { [K in keyof FilterRequestModules<Resource>]: AnyHandler<Resource[K]> },
             any,
-            Make["strict"] extends false ? any : MakeDepsOut<Make>
+            any
           >
-          strict?: boolean
           /** @deprecated */
           readonly ಠ_ಠ: never
         }
@@ -607,12 +576,11 @@ export const makeRouter = <
       <
         const Make extends {
           dependencies?: Array<Layer.Layer.Any>
-          effect: Effect<
+          effect: (match: typeof router3) => Effect<
             { [K in keyof FilterRequestModules<Resource>]: AnyHandler<Resource[K]> },
             any,
-            Make["strict"] extends false ? any : MakeDepsOut<Make>
+            any
           >
-          strict?: boolean
           /** @deprecated */
           readonly ಠ_ಠ: never
         }
@@ -640,12 +608,11 @@ export const makeRouter = <
       <
         const Make extends {
           dependencies?: Array<Layer.Layer.Any>
-          effect: Effect<
+          effect: (match: typeof router3) => Effect<
             { [K in keyof FilterRequestModules<Resource>]: AnyHandler<Resource[K]> },
             any,
-            MakeDepsOut<Make>
+            any
           >
-          strict?: boolean
           /** @deprecated */
           readonly ಠ_ಠ: never
         }
@@ -673,12 +640,11 @@ export const makeRouter = <
       <
         const Make extends {
           dependencies?: Array<Layer.Layer.Any>
-          effect: Effect<
+          effect: (match: typeof router3) => Effect<
             { [K in keyof FilterRequestModules<Resource>]: AnyHandler<Resource[K]> },
             any,
-            MakeDepsOut<Make>
+            any
           >
-          strict?: boolean
         }
       >(
         make: Make
@@ -709,16 +675,12 @@ export const makeRouter = <
               Effect<
                 any,
                 any,
-                Make["strict"] extends false ? any
-                  : Make extends { dependencies: Array<Layer.Layer.Any> } ? MakeDepsOut<Make>
-                  : any
+                any
               >
             >,
             { [K in keyof FilterRequestModules<Resource>]: AnyHandler<Resource[K]> },
             any
           >
-
-          strict?: boolean
         }
       >(
         make: Make
@@ -745,15 +707,14 @@ export const makeRouter = <
         const Make extends {
           dependencies: [
             ...Make["dependencies"],
-            ...Exclude<Effect.Context<Make["effect"]>, MakeDepsOut<Make>> extends never ? []
-              : [Layer.Layer<Exclude<Effect.Context<Make["effect"]>, MakeDepsOut<Make>>, never, never>]
+            ...Exclude<Effect.Context<ReturnType<Make["effect"]>>, MakeDepsOut<Make>> extends never ? []
+              : [Layer.Layer<Exclude<Effect.Context<ReturnType<Make["effect"]>>, MakeDepsOut<Make>>, never, never>]
           ]
-          effect: Effect<
+          effect: (match: typeof router3) => Effect<
             { [K in keyof FilterRequestModules<Resource>]: AnyHandler<Resource[K]> },
             any,
             any
           >
-          strict?: boolean
         }
       >(
         make: Make
@@ -776,10 +737,10 @@ export const makeRouter = <
         make: Make
       }
     } =
-      ((make: { dependencies: any; effect: any; strict?: any }) =>
+      ((make: { dependencies: any; effect: any }) =>
         Object.assign(makeRoutes(make.dependencies, make.effect), { make })) as any
 
-    return Object.assign(effect, routeMatcher, { router, router3 })
+    return effect
   }
 
   function matchAll<
@@ -804,12 +765,6 @@ export const makeRouter = <
 
   return {
     matchAll,
-    matchFor: <
-      const ModuleName extends string,
-      const Resource extends Record<string, any>
-    >(
-      rsc: Resource & { meta: { moduleName: ModuleName } }
-    ) => matchFor(rsc).router3,
     Router: matchFor
   }
 }
@@ -818,21 +773,26 @@ export type MakeDeps<Make> = Make extends { readonly dependencies: ReadonlyArray
   ? Make["dependencies"][number]
   : never
 
-export type MakeErrors<Make> = Make extends { readonly effect: Effect<any, infer E, any> } ? E
-  : Make extends { readonly effect: (_: any) => Generator<YieldWrap<Effect<any, infer E, any>>, any, any> } ? E
+export type MakeErrors<Make> = Make extends { readonly effect: (_: any) => Effect<infer _A, infer E, infer _R> } ? E
+  : Make extends { readonly effect: (_: any) => Effect<infer _A, never, infer _R> } ? never
+  : Make extends
+    { readonly effect: (_: any) => Generator<YieldWrap<Effect<infer _A, never, infer _R>>, infer _A, infer _2> } ? never
+  : Make extends
+    { readonly effect: (_: any) => Generator<YieldWrap<Effect<infer _A, infer E, infer _R>>, infer _A, infer _2> } ? E
   : never
 
-export type MakeContext<Make> = Make extends { readonly effect: Effect<any, any, infer R> } ? R
-  : Make extends { readonly effect: (_: any) => Generator<YieldWrap<Effect<any, any, infer R>>, any, any> } ? R
+export type MakeContext<Make> = Make extends { readonly effect: (_: any) => Effect<infer _A, infer _E, infer R> } ? R
+  : Make extends { readonly effect: (_: any) => Effect<infer _A, infer _E, never> } ? never
+  : Make extends
+    { readonly effect: (_: any) => Generator<YieldWrap<Effect<infer _A, infer _E, never>>, infer _A, infer _2> } ? never
+  : Make extends
+    { readonly effect: (_: any) => Generator<YieldWrap<Effect<infer _A, infer _E, infer R>>, infer _A, infer _2> } ? R
   : never
 
 export type MakeHandlers<Make, Handlers extends Record<string, any>> = Make extends
-  { readonly effect: Effect<{ [K in keyof Handlers]: AnyHandler<Handlers[K]> }, any, any> }
-  ? Effect.Success<Make["effect"]>
-  : Make extends { readonly effect: (_: any) => Generator<YieldWrap<any>, infer S, any> } ? S
+  { readonly effect: (_: any) => Effect<{ [K in keyof Handlers]: AnyHandler<Handlers[K]> }, any, any> }
+  ? Effect.Success<ReturnType<Make["effect"]>>
+  : Make extends { readonly effect: (_: any) => Generator<YieldWrap<any>, infer S, infer _R> } ? S
   : never
 
-/**
- * @since 3.9.0
- */
 export type MakeDepsOut<Make> = Contravariant.Type<MakeDeps<Make>[Layer.LayerTypeId]["_ROut"]>

package/test/controller.test.ts

@@ -237,7 +237,7 @@ export class SomethingService2 extends Effect.Service<SomethingService2>()("Some
   })
 }) {}
 
-export const { Router, matchAll, matchFor } = makeRouter(middleware, true)
+export const { Router, matchAll } = makeRouter(middleware, true)
 
 export const r2 = makeRouter(middleware2, true)
 
@@ -247,7 +247,7 @@ const router = Router(Something)({
     SomethingService.Default,
     SomethingService2.Default
   ],
-  *effect(match) {
+  effect: Effect.fnUntraced(function*(match) {
     const repo = yield* SomethingRepo
     const smth = yield* SomethingService
     const smth2 = yield* SomethingService2
@@ -300,7 +300,7 @@ const router = Router(Something)({
         raw: Some.use(() => Effect.succeed("12"))
       }
     })
-  }
+  })
 })
 
 it("sorts based on requirements", () => {

package/test/dist/controller.test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"controller.test.d.ts","sourceRoot":"","sources":["../controller.test.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,UAAU,EAAc,MAAM,+BAA+B,CAAA;AAE7F,OAAO,EAAW,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAE7D,OAAO,EAA6C,UAAU,EAAO,MAAM,kCAAkC,CAAA;AAE7G,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,iBAAiB,EAAE,YAAY,EAAE,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,eAAe,CAAA;;;;;;AAgEhI,cAAM,kBAAmB,SAAQ,uBAU/B;CAAG;;;;;;AAML,qBAAa,eAAgB,SAAQ,oBAYnC;CACD;AA2DD,eAAO,MAAM,WAAW;;;;;;YAIM,CAAA;AAE9B,MAAM,MAAM,aAAa,GAAG;IAC1B,yCAAyC;IACzC,cAAc,CAAC,EAAE,IAAI,CAAA;IACrB,iEAAiE;IACjE,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAC/B,CAAA;AACD,eAAO,MAAuB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAI/B,CAAA;;;;;;;;;;AAEF,qBAAa,GAAI,SAAQ,QAA0C;CAAG;;;;;;;;;;AACtE,qBAAa,GAAI,SAAQ,QAA0C;CAAG;;;;;;;;;;;;AAEtE,qBAAa,WAAY,SAAQ,gBAEV;CAAG;;;;;;;;;;;;AAgB1B,qBAAa,YAAa,SAAQ,iBAET;CAAG;;;;;;;;;;;;AAE5B,qBAAa,aAAc,SAAQ,kBAEA;CAAG;;;;;AAItC,qBAAa,gBAAiB,SAAQ,qBAKpC;CAAG;;;;;AASL,qBAAa,aAAc,SAAQ,kBAOjC;CAAG;;;;;AAEL,qBAAa,iBAAkB,SAAQ,sBAKrC;CAAG;AAEL,eAAO,MAAQ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAE,QAAQ;;;;;2HAAE,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uCAAiC,CAAA;AAE1E,eAAO,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAgC,CAAA"}
+{"version":3,"file":"controller.test.d.ts","sourceRoot":"","sources":["../controller.test.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,UAAU,EAAc,MAAM,+BAA+B,CAAA;AAE7F,OAAO,EAAW,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAE7D,OAAO,EAA6C,UAAU,EAAO,MAAM,kCAAkC,CAAA;AAE7G,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,iBAAiB,EAAE,YAAY,EAAE,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,eAAe,CAAA;;;;;;AAgEhI,cAAM,kBAAmB,SAAQ,uBAU/B;CAAG;;;;;;AAML,qBAAa,eAAgB,SAAQ,oBAYnC;CACD;AA2DD,eAAO,MAAM,WAAW;;;;;;YAIM,CAAA;AAE9B,MAAM,MAAM,aAAa,GAAG;IAC1B,yCAAyC;IACzC,cAAc,CAAC,EAAE,IAAI,CAAA;IACrB,iEAAiE;IACjE,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAC/B,CAAA;AACD,eAAO,MAAuB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAI/B,CAAA;;;;;;;;;;AAEF,qBAAa,GAAI,SAAQ,QAA0C;CAAG;;;;;;;;;;AACtE,qBAAa,GAAI,SAAQ,QAA0C;CAAG;;;;;;;;;;;;AAEtE,qBAAa,WAAY,SAAQ,gBAEV;CAAG;;;;;;;;;;;;AAgB1B,qBAAa,YAAa,SAAQ,iBAET;CAAG;;;;;;;;;;;;AAE5B,qBAAa,aAAc,SAAQ,kBAEA;CAAG;;;;;AAItC,qBAAa,gBAAiB,SAAQ,qBAKpC;CAAG;;;;;AASL,qBAAa,aAAc,SAAQ,kBAOjC;CAAG;;;;;AAEL,qBAAa,iBAAkB,SAAQ,sBAKrC;CAAG;AAEL,eAAO,MAAQ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAE,QAAQ;;;;;yHAAiC,CAAA;AAEhE,eAAO,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAgC,CAAA"}