@effect-app/infra 0.168.0 → 0.169.0

package/_src/api/routing/makeRequestHandler.ts

@@ -54,7 +54,7 @@ export type Middleware<
     Context,
     Config
   >
-  makeRequestLayer: Layer<R2, MiddlewareE, PR>
+  makeRequestLayer: Layer<PR, MiddlewareE, R2>
 }
 
 export function makeRequestHandler<
@@ -92,20 +92,16 @@ export function makeRequestHandler<
   errorHandler: <R>(
     req: HttpServerRequest,
     res: HttpServerResponse,
-    r2: Effect<R, ValidationError | ResE | MiddlewareE, HttpServerResponse>
-  ) => Effect<RErr | R, never, HttpServerResponse>,
-  middlewareLayer?: Layer<R2, MiddlewareE, PR>
-): Effect<
-  | HttpRouteContext
-  | HttpServerRequest
-  | RequestContextContainer
-  | ContextMapContainer
-  | RErr
-  | Exclude<Exclude<R, EnforceNonEmptyRecord<M>>, PR>
-  | R2,
-  HttpRequestError,
-  HttpServerResponse
-> {
+    r2: Effect<HttpServerResponse, ValidationError | ResE | MiddlewareE, R>
+  ) => Effect<HttpServerResponse, never, RErr | R>,
+  middlewareLayer?: Layer<PR, MiddlewareE, R2>
+): Effect<HttpServerResponse, HttpRequestError, | HttpRouteContext
+| HttpServerRequest
+| RequestContextContainer
+| ContextMapContainer
+| RErr
+| Exclude<Exclude<R, EnforceNonEmptyRecord<M>>, PR>
+| R2> {
   const { Request, Response, h: handle } = handler
 
   const response: REST.ReqRes<any, any, any> = Response ? Response : Void
@@ -158,15 +154,13 @@ export function makeRequestHandler<
           .annotateLogs({
             method: req.method,
             path: req.originalUrl,
-            ...settings.verbose
-              ? {
+            ...(settings.verbose ? {
                 reqPath: pars.params.$$.pretty,
                 reqQuery: pars.query.$$.pretty,
                 reqBody: pretty(pars.body),
                 reqCookies: pretty(pars.cookies),
                 reqHeaders: pretty(pars.headers)
-              }
-              : undefined
+              } : undefined)
           })
           .andThen(
             Effect.suspend(() => {
@@ -189,9 +183,9 @@ export function makeRequestHandler<
                         .setStatus(r === undefined ? 204 : 200)
                     )
                 ) as Effect<
-                  Exclude<R, EnforceNonEmptyRecord<M>>,
+                  HttpServerResponse,
                   ValidationError | ResE,
-                  HttpServerResponse
+                  Exclude<R, EnforceNonEmptyRecord<M>>
                 >
 
               // Commands should not be interruptable.
@@ -200,9 +194,9 @@ export function makeRequestHandler<
                 ? r.provide(middlewareLayer)
                 // PR is not relevant here
                 : (r as Effect<
-                  Exclude<Exclude<R, EnforceNonEmptyRecord<M>>, PR>,
+                  HttpServerResponse,
                   ResE | MiddlewareE | ValidationError,
-                  HttpServerResponse
+                  Exclude<Exclude<R, EnforceNonEmptyRecord<M>>, PR>
                 >)
               return errorHandler(
                 req,
@@ -257,11 +251,9 @@ export function makeRequestHandler<
                 method: req.method,
                 path: req.originalUrl,
                 statusCode: res.status.toString(),
-                ...settings.verbose
-                  ? {
+                ...(settings.verbose ? {
                     resHeaders: pretty(res.headers)
-                  }
-                  : undefined
+                  } : undefined)
               })
           )
 
@@ -273,5 +265,5 @@ export function makeRequestHandler<
           handler.name
         )
       })
-    )
+    );
 }

package/_src/api/routing/match.ts

@@ -8,7 +8,7 @@ import type { RequestHandler } from "./base.js"
 import { makeRequestHandler } from "./makeRequestHandler.js"
 import type { Middleware } from "./makeRequestHandler.js"
 
-export const RouteDescriptors = Tag<Ref<RouteDescriptorAny[]>>()
+export const RouteDescriptors = GenericTag<Ref<RouteDescriptorAny[]>>("@services/RouteDescriptors")
 
 export function match<
   R,
@@ -49,8 +49,8 @@ export function match<
   errorHandler: <R>(
     req: HttpServerRequest,
     res: HttpServerResponse,
-    r2: Effect<R, ValidationError | MiddlewareE | ResE, HttpServerResponse>
-  ) => Effect<RErr | R, never, HttpServerResponse>,
+    r2: Effect<HttpServerResponse, ValidationError | MiddlewareE | ResE, R>
+  ) => Effect<HttpServerResponse, never, RErr | R>,
   middleware?: Middleware<
     R,
     M,
@@ -71,7 +71,7 @@ export function match<
     Config
   >
 ) {
-  let middlewareLayer: Layer<R2, MiddlewareE, PR> | undefined = undefined
+  let middlewareLayer: Layer<PR, MiddlewareE, R2> | undefined = undefined
   if (middleware) {
     const { handler, makeRequestLayer } = middleware(requestHandler)
     requestHandler = handler as any // todo

package/_src/api/setupRequest.ts

@@ -15,7 +15,7 @@ function makeInternalRequestContext(name: string) {
   })
 }
 
-const withRequestSpan = <R, E, A>(f: Effect<R, E, A>) =>
+const withRequestSpan = <R, E, A>(f: Effect<A, E, R>) =>
   RequestContextContainer
     .get
     .andThen((ctx) =>
@@ -50,7 +50,7 @@ const RequestContextStartLive = (requestContext: RequestContext | string) =>
 /**
  * @tsplus fluent effect/io/Effect setupRequestContext
  */
-export function setupRequestContext<R, E, A>(self: Effect<R, E, A>, requestContext: RequestContext | string) {
+export function setupRequestContext<R, E, A>(self: Effect<A, E, R>, requestContext: RequestContext | string) {
   return self
     .pipe(withRequestSpan)
     .provide(RequestContextStartLive(requestContext))
@@ -62,7 +62,7 @@ const UpdateRequestContextLive = (f: (rc: RequestContext) => RequestContext) =>
 /**
  * @tsplus fluent effect/io/Effect updateRequestContext
  */
-export function updateRequestContext<R, E, A>(self: Effect<R, E, A>, f: (rc: RequestContext) => RequestContext) {
+export function updateRequestContext<R, E, A>(self: Effect<A, E, R>, f: (rc: RequestContext) => RequestContext) {
   return self
     // .provideServiceEffect(RequestContext.Tag, RequestContextContainer.get)
     .provide(UpdateRequestContextLive(f))

package/_src/logger/logFmtLogger.ts

@@ -14,7 +14,7 @@ export const logfmtLogger = Logger.make<unknown, void>(
           "request.name": requestContext.name,
           "request.namespace": requestContext.namespace,
           "request.locale": requestContext.locale,
-          ...requestContext.userProfile?.sub ? { "request.user.sub": requestContext.userProfile.sub } : {}
+          ...(requestContext.userProfile?.sub ? { "request.user.sub": requestContext.userProfile.sub } : {})
         }
           .$$
           .entries

package/_src/rateLimit.ts

@@ -33,7 +33,7 @@
  * @tsplus pipeable effect/io/Effect/Semaphore withPermitsDuration
  */
 export function SEM_withPermitsDuration(permits: number, duration: Duration) {
-  return (self: Semaphore): <R, E, A>(effect: Effect<R, E, A>) => Effect<R, E, A> => {
+  return (self: Semaphore): <R, E, A>(effect: Effect<A, E, R>) => Effect<A, E, R> => {
     return (effect) =>
       Effect.uninterruptibleMask(
         (restore) =>
@@ -47,7 +47,7 @@ export function SEM_withPermitsDuration(permits: number, duration: Duration) {
                 )
             )
       )
-  }
+  };
 }
 
 /**
@@ -56,8 +56,8 @@ export function SEM_withPermitsDuration(permits: number, duration: Duration) {
  */
 export function batchPar<R, E, A, R2, E2, A2, T>(
   n: number,
-  forEachItem: (item: T, iWithinBatch: number, batchI: number) => Effect<R, E, A>,
-  forEachBatch: (a: NonEmptyArray<A>, i: number) => Effect<R2, E2, A2>
+  forEachItem: (item: T, iWithinBatch: number, batchI: number) => Effect<A, E, R>,
+  forEachBatch: (a: NonEmptyArray<A>, i: number) => Effect<A2, E2, R2>
 ) {
   return (items: Iterable<T>) =>
     items
@@ -77,8 +77,8 @@ export function batchPar<R, E, A, R2, E2, A2, T>(
  */
 export function batch<R, E, A, R2, E2, A2, T>(
   n: number,
-  forEachItem: (item: T, iWithinBatch: number, batchI: number) => Effect<R, E, A>,
-  forEachBatch: (a: NonEmptyArray<A>, i: number) => Effect<R2, E2, A2>
+  forEachItem: (item: T, iWithinBatch: number, batchI: number) => Effect<A, E, R>,
+  forEachBatch: (a: NonEmptyArray<A>, i: number) => Effect<A2, E2, R2>
 ) {
   return (items: Iterable<T>) =>
     items
@@ -120,8 +120,8 @@ export function naiveRateLimit(
   d: DUR
 ) {
   return <T>(items: Iterable<T>) => (<R, E, A, R2, E2, A2>(
-    forEachItem: (i: T) => Effect<R, E, A>,
-    forEachBatch: (a: A[]) => Effect<R2, E2, A2>
+    forEachItem: (i: T) => Effect<A, E, R>,
+    forEachBatch: (a: A[]) => Effect<A2, E2, R2>
   ) =>
     items
       .chunk(n)
@@ -132,5 +132,5 @@ export function naiveRateLimit(
               .forEachEffect(forEachItem, { concurrency: n })
               .flatMap(forEachBatch)
           )
-      ))
+      ));
 }

package/_src/services/Emailer/Sendgrid.ts

@@ -24,11 +24,7 @@ const makeSendgrid = ({ apiKey, defaultFrom, defaultReplyTo, realMail, subjectPr
           yield* $(Effect.logDebug("Sending email").annotateLogs("msg", inspect(renderedMsg, false, 5)))
 
           const ret = yield* $(
-            Effect.async<
-              never,
-              Error | sgMail.ResponseError,
-              [sgMail.ClientResponse, Record<string, unknown>]
-            >(
+            Effect.async<[sgMail.ClientResponse, Record<string, unknown>], Error | sgMail.ResponseError>(
               (cb) =>
                 void sgMail.send(renderedMsg, false, (err, result) =>
                   err
@@ -47,9 +43,9 @@ const makeSendgrid = ({ apiKey, defaultFrom, defaultReplyTo, realMail, subjectPr
           // const { trackEvent } = yield* $(AiContextService)
           // trackEvent(event)
           return ret
-        })
+        });
       }
-    }
+    };
   })
 
 /**

package/_src/services/Emailer/service.ts

@@ -7,7 +7,7 @@ import type sgMail from "@sendgrid/mail"
  * @tsplus companion Emailer.Ops
  */
 export class Emailer extends TagClass<Emailer, {
-  sendMail: (msg: EmailMsgOptionalFrom) => Effect<never, Error | ResponseError, void>
+  sendMail: (msg: EmailMsgOptionalFrom) => Effect<void, Error | ResponseError>
 }>() {}
 
 export interface SendgridConfig {

package/_src/services/Operations/service.ts

@@ -6,10 +6,10 @@ import * as Scope from "effect/Scope"
  * @tsplus companion Operations.Ops
  */
 export class Operations extends TagClass<Operations.Id, {
-  register: Effect<Scope.Scope, never, OperationId>
-  update: (id: OperationId, progress: OperationProgress) => Effect<never, never, void>
-  find: (id: OperationId) => Effect<never, never, Option<Operation>>
-  cleanup: Effect<never, never, void>
+  register: Effect<OperationId, never, Scope.Scope>
+  update: (id: OperationId, progress: OperationProgress) => Effect<void>
+  find: (id: OperationId) => Effect<Option<Operation>>
+  cleanup: Effect<void>
 }, Operations>() {}
 export namespace Operations {
   export interface Id {
@@ -20,7 +20,7 @@ export namespace Operations {
 /**
  * @tsplus getter effect/io/Effect forkOperation
  */
-export function forkOperation<R, E, A>(self: Effect<R, E, A>) {
+export function forkOperation<R, E, A>(self: Effect<A, E, R>) {
   return Operations.flatMap(
     (Operations) =>
       Scope
@@ -37,14 +37,14 @@ export function forkOperation<R, E, A>(self: Effect<R, E, A>) {
 /**
  * @tsplus getter function forkOperation
  */
-export function forkOperationFunction<R, E, A, Inp>(fnc: (inp: Inp) => Effect<R, E, A>) {
+export function forkOperationFunction<R, E, A, Inp>(fnc: (inp: Inp) => Effect<A, E, R>) {
   return (inp: Inp) => fnc(inp).forkOperation
 }
 
 /**
  * @tsplus static effect/io/Effect.Ops forkOperation
  */
-export function forkOperation2<R, E, A>(self: (opId: OperationId) => Effect<R, E, A>) {
+export function forkOperation2<R, E, A>(self: (opId: OperationId) => Effect<A, E, R>) {
   return Operations.flatMap(
     (Operations) =>
       Scope
@@ -62,8 +62,8 @@ export function forkOperation2<R, E, A>(self: (opId: OperationId) => Effect<R, E
  * @tsplus static effect/io/Effect.Ops forkOperationWithEffect
  */
 export function forkOperationWithEffect<R, R2, E, E2, A, A2>(
-  self: (id: OperationId) => Effect<R, E, A>,
-  fnc: (id: OperationId) => Effect<R2, E2, A2>
+  self: (id: OperationId) => Effect<A, E, R>,
+  fnc: (id: OperationId) => Effect<A2, E2, R2>
 ) {
   return Operations.flatMap(
     (Operations) =>

package/_src/services/QueueMaker/errors.ts

@@ -14,7 +14,7 @@ export const reportQueueError = <E>(cause: Cause<E>, extras?: Record<string, unk
  *
  * @tsplus getter effect/io/Effect forkDaemonReportQueue
  */
-export function forkDaemonReportQueue<R, E, A>(self: Effect<R, E, A>) {
+export function forkDaemonReportQueue<R, E, A>(self: Effect<A, E, R>) {
   return self.tapErrorCause(reportNonInterruptedFailureCause({})).fork.daemonChildren
 }
 
@@ -24,19 +24,19 @@ export const reportFatalQueueError = reportError(
 
 export function reportNonInterruptedFailure(context?: Record<string, unknown>) {
   const report = reportNonInterruptedFailureCause(context)
-  return <R, E, A>(inp: Effect<R, E, A>): Effect<R, never, Exit<E, A>> =>
+  return <R, E, A>(inp: Effect<A, E, R>): Effect<Exit<A, E>, never, R> =>
     inp
       .exit
       .flatMap((result) =>
         result.match({ onFailure: (cause) => report(cause).map(() => result), onSuccess: () => Effect.sync(() => result) })
-      )
+      );
 }
 
 export function reportNonInterruptedFailureCause(context?: Record<string, unknown>) {
-  return <E>(cause: Cause<E>): Effect<never, never, void> => {
+  return <E>(cause: Cause<E>): Effect<void> => {
     if (cause.isInterrupted()) {
       return (cause as Cause<never>).failCause
     }
     return reportQueueError(cause, context)
-  }
+  };
 }

package/_src/services/QueueMaker/memQueue.ts

@@ -18,8 +18,8 @@ export function makeMemQueue<
 >(
   queueName: string,
   queueDrainName: string,
-  schema: S.Schema<never, EvtE, Evt>,
-  drainSchema: S.Schema<never, DrainEvtE, DrainEvt>
+  schema: S.Schema<Evt, EvtE>,
+  drainSchema: S.Schema<DrainEvt, DrainEvtE>
 ) {
   return Effect.gen(function*($) {
     const mem = yield* $(MemQueue)
@@ -53,7 +53,7 @@ export function makeMemQueue<
           )
         }),
       makeDrain: <DrainE, DrainR>(
-        handleEvent: (ks: DrainEvt) => Effect<DrainR, DrainE, void>
+        handleEvent: (ks: DrainEvt) => Effect<void, DrainE, DrainR>
       ) =>
         Effect.gen(function*($) {
           const silenceAndReportError = reportNonInterruptedFailure({ name: "MemQueue.drain." + queueDrainName })
@@ -92,6 +92,6 @@ export function makeMemQueue<
               .forkScoped
           )
         })
-    } satisfies QueueBase<Evt, DrainEvt>
-  })
+    } satisfies QueueBase<Evt, DrainEvt>;
+  });
 }

package/_src/services/QueueMaker/sbqueue.ts

@@ -28,8 +28,8 @@ export function makeServiceBusQueue<
 >(
   _queueName: string,
   queueDrainName: string,
-  schema: S.Schema<never, EvtE, Evt>,
-  drainSchema: S.Schema<never, DrainEvtE, DrainEvt>
+  schema: S.Schema<Evt, EvtE>,
+  drainSchema: S.Schema<DrainEvt, DrainEvtE>
 ) {
   const wireSchema = struct({
     body: schema,
@@ -48,7 +48,7 @@ export function makeServiceBusQueue<
 
     return {
       makeDrain: <DrainE, DrainR>(
-        handleEvent: (ks: DrainEvt) => Effect<DrainR, DrainE, void>
+        handleEvent: (ks: DrainEvt) => Effect<void, DrainE, DrainR>
       ) =>
         Effect.gen(function*($) {
           // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -111,8 +111,8 @@ export function makeServiceBusQueue<
               .forkDaemonReportQueue
           )
         })
-    } satisfies QueueBase<Evt, DrainEvt>
-  })
+    } satisfies QueueBase<Evt, DrainEvt>;
+  });
 }
 
 /**

package/_src/services/QueueMaker/service.ts

@@ -4,11 +4,11 @@ import type { ContextMapContainer } from "../Store/ContextMapContainer.js"
 
 export interface QueueBase<Evt, DrainEvt> {
   makeDrain: <DrainE, DrainR>(
-    makeHandleEvent: (ks: DrainEvt) => Effect<DrainR, DrainE, void>
-  ) => Effect<Scope | RequestContextContainer | ContextMapContainer | DrainR, never, void>
+    makeHandleEvent: (ks: DrainEvt) => Effect<void, DrainE, DrainR>
+  ) => Effect<void, never, Scope | RequestContextContainer | ContextMapContainer | DrainR>
   publish: (
     ...messages: NonEmptyReadonlyArray<Evt>
-  ) => Effect<never, never, void>
+  ) => Effect<void>
 }
 
 /**