@effect-app/infra 0.48.0 → 0.49.0

package/_src/api/routing.ts

@@ -47,44 +47,49 @@ export function makeRequestParsers<
   >["Request"]
 ): RequestParsers<PathA, CookieA, QueryA, BodyA, HeaderA> {
   const ph = Effect(
-    Option.fromNullable(Request.Headers)
-      .map(s => s)
+    Option
+      .fromNullable(Request.Headers)
+      .map((s) => s)
       .map(Parser.for)
       .map(MO.condemnFail)
   )
-  const parseHeaders = (u: unknown) => ph.flatMapOpt(d => d(u))
+  const parseHeaders = (u: unknown) => ph.flatMapOpt((d) => d(u))
 
   const pq = Effect(
-    Option.fromNullable(Request.Query)
-      .map(s => s)
+    Option
+      .fromNullable(Request.Query)
+      .map((s) => s)
       .map(Parser.for)
       .map(MO.condemnFail)
   )
-  const parseQuery = (u: unknown) => pq.flatMapOpt(d => d(u))
+  const parseQuery = (u: unknown) => pq.flatMapOpt((d) => d(u))
 
   const pb = Effect(
-    Option.fromNullable(Request.Body)
-      .map(s => s)
+    Option
+      .fromNullable(Request.Body)
+      .map((s) => s)
       .map(Parser.for)
       .map(MO.condemnFail)
   )
-  const parseBody = (u: unknown) => pb.flatMapOpt(d => d(u))
+  const parseBody = (u: unknown) => pb.flatMapOpt((d) => d(u))
 
   const pp = Effect(
-    Option.fromNullable(Request.Path)
-      .map(s => s)
+    Option
+      .fromNullable(Request.Path)
+      .map((s) => s)
       .map(Parser.for)
       .map(MO.condemnFail)
   )
-  const parsePath = (u: unknown) => pp.flatMapOpt(d => d(u))
+  const parsePath = (u: unknown) => pp.flatMapOpt((d) => d(u))
 
   const pc = Effect(
-    Option.fromNullable(Request.Cookie)
-      .map(s => s)
+    Option
+      .fromNullable(Request.Cookie)
+      .map((s) => s)
       .map(Parser.for)
       .map(MO.condemnFail)
   )
-  const parseCookie = (u: unknown) => pc.flatMapOpt(d => d(u))
+  const parseCookie = (u: unknown) => pc.flatMapOpt((d) => d(u))
 
   return {
     parseBody,
@@ -169,22 +174,24 @@ export function match<
     requestHandler = handler
     makeMiddlewareContext = makeContext
   }
-  return Ex.match(requestHandler.Request.method.toLowerCase() as any)(
-    requestHandler.Request.path.split("?")[0],
-    makeRequestHandler<R, E, PathA, CookieA, QueryA, BodyA, HeaderA, ReqA, ResA, R2, PR, RErr>(
-      requestHandler,
-      errorHandler,
-      makeMiddlewareContext
+  return Ex
+    .match(requestHandler.Request.method.toLowerCase() as any)(
+      requestHandler.Request.path.split("?")[0],
+      makeRequestHandler<R, E, PathA, CookieA, QueryA, BodyA, HeaderA, ReqA, ResA, R2, PR, RErr>(
+        requestHandler,
+        errorHandler,
+        makeMiddlewareContext
+      )
     )
-  ).zipRight(
-    Effect(
-      makeRouteDescriptor(
-        requestHandler.Request.path,
-        requestHandler.Request.method,
-        requestHandler
+    .zipRight(
+      Effect(
+        makeRouteDescriptor(
+          requestHandler.Request.path,
+          requestHandler.Request.method,
+          requestHandler
+        )
       )
     )
-  )
 }
 
 export function respondSuccess<ReqA, A, E>(
@@ -192,11 +199,12 @@ export function respondSuccess<ReqA, A, E>(
 ) {
   return (req: ReqA, res: express.Response, a: A) =>
     Effect(encodeResponse(req)(a))
-      .flatMap(r =>
+      .flatMap((r) =>
         Effect.sync(() => {
           r === undefined
             ? res.status(204).send()
-            : res.status(200)
+            : res
+              .status(200)
               .send(JSON.stringify(r))
         })
       )
@@ -300,122 +308,136 @@ export function makeRequestHandler<
   }
 
   return (req: express.Request, res: express.Response) => {
-    return Debug.untraced(restore =>
-      Effect.all({
-        requestContext: Effect.sync(() => {
-          const requestContext = makeContext(req)
-          if (req.method === "GET") {
-            res.setHeader("Cache-Control", "no-store")
-          }
-          res.setHeader("Content-Language", requestContext.locale)
-          return requestContext
-        }),
-        pars: getParams(req)
-      })
+    return Debug.untraced((restore) =>
+      Effect
+        .all({
+          requestContext: Effect.sync(() => {
+            const requestContext = makeContext(req)
+            if (req.method === "GET") {
+              res.setHeader("Cache-Control", "no-store")
+            }
+            res.setHeader("Content-Language", requestContext.locale)
+            return requestContext
+          }),
+          pars: getParams(req)
+        })
         .flatMap(({ pars, requestContext }) =>
-          RequestSettings.get.flatMap(s =>
-            // TODO: we don;t have access to user id here cause context is not yet created
-            Effect.logInfo("Incoming request").apply(
-              Effect.logAnnotates({
-                method: req.method,
-                path: req.originalUrl,
-                ...s.verbose
-                  ? {
-                    reqPath: pars.path.$$.pretty,
-                    reqQuery: pars.query.$$.pretty,
-                    reqBody: pretty(pars.body),
-                    reqCookies: pretty(pars.cookies),
-                    reqHeaders: pars.headers.$$.pretty
-                  } :
-                  undefined
-              })
-            )
-          ).zipRight(
-            Effect.suspend(() => {
-              const handleRequest = parseRequest(req)
-                .map(({ body, path, query }) => {
-                  const hn = {
-                    ...body.value,
-                    ...query.value,
-                    ...path.value
-                  } as unknown as ReqA
-                  return hn
+          RequestSettings
+            .get
+            .flatMap((s) =>
+              // TODO: we don;t have access to user id here cause context is not yet created
+              Effect.logInfo("Incoming request").apply(
+                Effect.logAnnotates({
+                  method: req.method,
+                  path: req.originalUrl,
+                  ...s.verbose
+                    ? {
+                      reqPath: pars.path.$$.pretty,
+                      reqQuery: pars.query.$$.pretty,
+                      reqBody: pretty(pars.body),
+                      reqCookies: pretty(pars.cookies),
+                      reqHeaders: pars.headers.$$.pretty
+                    }
+                    : undefined
                 })
-                .flatMap(parsedReq =>
-                  restore(() => handle(parsedReq as any))()
-                    .flatMap(r => respond(parsedReq, res, r))
-                )
-
-              // Commands should not be interruptable.
-              const r = req.method !== "GET" ? handleRequest.uninterruptible : handleRequest // .instrument("Performance.RequestResponse")
-              // the first log entry should be of the request start.
-              const r2 = makeMiddlewareContext
-                ? restoreFromRequestContext
-                  .zipRight(r.setupRequestFrom
-                    // the db namespace must be restored, before calling provide here
-                    .provideSomeContextEffect(makeMiddlewareContext(req, res)))
-                : restoreFromRequestContext
-                  // PR is not relevant here
-                  .zipRight(r) as Effect<R, E | ValidationError, void>
-              return errorHandler(
-                req,
-                res,
-                r2
               )
-            })
-          )
-            .tapErrorCause(cause =>
-              Effect.allPar(
-                Effect(res.status(500).send()),
-                RequestContextContainer.get.flatMap(requestContext =>
-                  reportRequestError(cause, {
-                    requestContext,
-                    path: req.originalUrl,
-                    method: req.method
+            )
+            .zipRight(
+              Effect.suspend(() => {
+                const handleRequest = parseRequest(req)
+                  .map(({ body, path, query }) => {
+                    const hn = {
+                      ...body.value,
+                      ...query.value,
+                      ...path.value
+                    } as unknown as ReqA
+                    return hn
+                  })
+                  .flatMap((parsedReq) =>
+                    restore(() => handle(parsedReq as any))()
+                      .flatMap((r) => respond(parsedReq, res, r))
+                  )
+
+                // Commands should not be interruptable.
+                const r = req.method !== "GET" ? handleRequest.uninterruptible : handleRequest // .instrument("Performance.RequestResponse")
+                // the first log entry should be of the request start.
+                const r2 = makeMiddlewareContext
+                  ? restoreFromRequestContext
+                    .zipRight(r
+                      .setupRequestFrom
+                      // the db namespace must be restored, before calling provide here
+                      .provideSomeContextEffect(makeMiddlewareContext(req, res)))
+                  : restoreFromRequestContext
+                    // PR is not relevant here
+                    .zipRight(r) as Effect<R, E | ValidationError, void>
+                return errorHandler(
+                  req,
+                  res,
+                  r2
+                )
+              })
+            )
+            .tapErrorCause((cause) =>
+              Effect
+                .allPar(
+                  Effect(res.status(500).send()),
+                  RequestContextContainer.get.flatMap((requestContext) =>
+                    reportRequestError(cause, {
+                      requestContext,
+                      path: req.originalUrl,
+                      method: req.method
+                    })
+                  ),
+                  Effect.suspend(() => {
+                    const headers = res.getHeaders()
+                    return Effect
+                      .logErrorCauseMessage(
+                        "Finished request",
+                        cause
+                      )
+                      .apply(Effect.logAnnotates({
+                        method: req.method,
+                        path: req.originalUrl,
+                        statusCode: res.statusCode.toString(),
+
+                        reqPath: pars.path.$$.pretty,
+                        reqQuery: pars.query.$$.pretty,
+                        reqBody: pretty(pars.body),
+                        reqCookies: pretty(pars.cookies),
+                        reqHeaders: pars.headers.$$.pretty,
+
+                        resHeaders: Object
+                          .entries(headers)
+                          .reduce((prev, [key, value]) => {
+                            prev[key] = value && typeof value === "string" ? snipString(value) : value
+                            return prev
+                          }, {} as Record<string, any>)
+                          .$$
+                          .pretty
+                      }))
                   })
-                ),
-                Effect.suspend(() => {
+                )
+                .tapErrorCause((cause) => Effect(console.error("Error occurred while reporting error", cause)))
+                .setupRequestFrom
+            )
+            .tap(() =>
+              RequestSettings
+                .get
+                .flatMap((s) => {
                   const headers = res.getHeaders()
-                  return Effect.logErrorCauseMessage(
-                    "Finished request",
-                    cause
-                  ).apply(Effect.logAnnotates({
+                  return Effect.logInfo("Finished request").apply(Effect.logAnnotates({
                     method: req.method,
                     path: req.originalUrl,
                     statusCode: res.statusCode.toString(),
-
-                    reqPath: pars.path.$$.pretty,
-                    reqQuery: pars.query.$$.pretty,
-                    reqBody: pretty(pars.body),
-                    reqCookies: pretty(pars.cookies),
-                    reqHeaders: pars.headers.$$.pretty,
-
-                    resHeaders: Object.entries(headers).reduce((prev, [key, value]) => {
-                      prev[key] = value && typeof value === "string" ? snipString(value) : value
-                      return prev
-                    }, {} as Record<string, any>)
-                      .$$.pretty
+                    ...s.verbose
+                      ? {
+                        resHeaders: headers.$$.pretty
+                      }
+                      : undefined
                   }))
                 })
-              )
-                .tapErrorCause(cause => Effect(console.error("Error occurred while reporting error", cause)))
                 .setupRequestFrom
             )
-            .tap(() =>
-              RequestSettings.get.flatMap(s => {
-                const headers = res.getHeaders()
-                return Effect.logInfo("Finished request").apply(Effect.logAnnotates({
-                  method: req.method,
-                  path: req.originalUrl,
-                  statusCode: res.statusCode.toString(),
-                  ...s.verbose
-                    ? {
-                      resHeaders: headers.$$.pretty
-                    } :
-                    undefined
-                }))
-              }).setupRequestFrom
-            )
             .setupRequestFrom
             .provideService(RequestContextContainer, new RequestContextContainerImpl(requestContext)) // otherwise external error reporter breaks.
         )
@@ -484,7 +506,7 @@ export function matchAll<T extends RequestHandlers>(handlers: T) {
 export function matchAllAlt<T extends RequestHandlersTest>(handlers: T) {
   const mapped = handlers.$$.keys.reduce((prev, cur) => {
     const matches = matchAll(handlers[cur])
-    matches.$$.keys.forEach(key => prev[`${cur as string}.${key as string}`] = matches[key])
+    matches.$$.keys.forEach((key) => prev[`${cur as string}.${key as string}`] = matches[key])
     return prev
   }, {} as any) as Flatten<RouteAllTest<typeof handlers>>
 

package/_src/api/setupRequest.ts

@@ -22,7 +22,9 @@ export function setupRequest<R, E, A>(self: Effect<R, E, A>, requestContext: Req
  * @tsplus getter effect/io/Effect setupRequestFrom
  */
 export function setupRequestFrom<R, E, A>(self: Effect<R, E, A>) {
-  return Debug.untraced(() => RequestContextContainer.get.flatMap(requestContext => self.setupRequest(requestContext)))
+  return Debug.untraced(() =>
+    RequestContextContainer.get.flatMap((requestContext) => self.setupRequest(requestContext))
+  )
 }
 
 /**

package/_src/api/writeDocs.ts

@@ -6,7 +6,8 @@ import type { RouteDescriptorAny } from "./express/schema/routing.js"
 
 export function writeOpenapiDocs(rdescs: Record<string, Record<string, RouteDescriptorAny>>) {
   return makeOpenApiSpecs(
-    typedValuesOf(rdescs).reduce((prev, cur) => prev.concat(typedValuesOf(cur)), [] as readonly RouteDescriptorAny[])
+    typedValuesOf(rdescs)
+      .reduce((prev, cur) => prev.concat(typedValuesOf(cur)), [] as readonly RouteDescriptorAny[])
       .sortWith(Order.string.contramap((a: RouteDescriptorAny) => a.path)),
     Plutus.info({
       title: "api",
@@ -14,12 +15,12 @@ export function writeOpenapiDocs(rdescs: Record<string, Record<string, RouteDesc
       pageTitle: "api"
     })
   )
-    .map(_ => ({
+    .map((_) => ({
       ..._,
       tags: [
         // add the tags here
       ]
     }))
-    .flatMap(_ => writeTextFile("./openapi.json", JSON.stringify(_, undefined, 2)).orDie)
+    .flatMap((_) => writeTextFile("./openapi.json", JSON.stringify(_, undefined, 2)).orDie)
     .flatMap(() => Effect.logInfo("OpenAPI spec written to './openapi.json'"))
 }

package/_src/rateLimit.ts

@@ -34,13 +34,14 @@
  */
 export function SEM_withPermitsDuration(permits: number, duration: Duration) {
   return (self: Semaphore): <R, E, A>(effect: Effect<R, E, A>) => Effect<R, E, A> => {
-    return effect =>
+    return (effect) =>
       Effect.uninterruptibleMask(
-        restore =>
+        (restore) =>
           restore(self.take(permits))
             > restore(effect)
               .ensuring(
-                self.release(permits)
+                self
+                  .release(permits)
                   .delay(duration)
               )
       )
@@ -54,13 +55,15 @@ 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: NonEmptyChunk<A>, i: number) => Effect<R2, E2, A2>
+  forEachBatch: (a: NonEmptyArray<A>, i: number) => Effect<R2, E2, A2>
 ) {
   return (items: Iterable<T>) =>
-    items.chunk(n)
+    items
+      .chunk(n)
       .forEachEffectParWithIndex((_, i) =>
-        _.forEachParWithIndex((_, j) => forEachItem(_, j, i))
-          .flatMap(_ => forEachBatch(_ as NonEmptyChunk<A>, i))
+        _
+          .forEachParWithIndex((_, j) => forEachItem(_, j, i))
+          .flatMap((_) => forEachBatch(_ as NonEmptyArray<A>, i))
       )
 }
 
@@ -71,13 +74,15 @@ 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: NonEmptyChunk<A>, i: number) => Effect<R2, E2, A2>
+  forEachBatch: (a: NonEmptyArray<A>, i: number) => Effect<R2, E2, A2>
 ) {
   return (items: Iterable<T>) =>
-    items.chunk(n)
+    items
+      .chunk(n)
       .forEachEffectWithIndex((_, i) =>
-        _.forEachParWithIndex((_, j) => forEachItem(_, j, i))
-          .flatMap(_ => forEachBatch(_ as NonEmptyChunk<A>, i))
+        _
+          .forEachParWithIndex((_, j) => forEachItem(_, j, i))
+          .flatMap((_) => forEachBatch(_ as NonEmptyArray<A>, i))
       )
 }
 
@@ -112,13 +117,15 @@ export function naiveRateLimit(
 ) {
   return <T>(items: Iterable<T>) => (<R, E, A, R2, E2, A2>(
     forEachItem: (i: T) => Effect<R, E, A>,
-    forEachBatch: (a: Chunk<A>) => Effect<R2, E2, A2>
+    forEachBatch: (a: A[]) => Effect<R2, E2, A2>
   ) =>
-    items.chunk(n)
+    items
+      .chunk(n)
       .forEachEffectWithIndex((batch, i) =>
         ((i === 0) ? Effect.unit : Effect.sleep(d))
           .zipRight(
-            batch.forEachEffectPar(forEachItem)
+            batch
+              .forEachEffectPar(forEachItem)
               .withParallelism(n)
               .flatMap(forEachBatch)
           )

package/_src/services/Emailer/Sendgrid.ts

@@ -28,11 +28,11 @@ const makeLiveSendgrid = ({ apiKey, defaultFrom, defaultReplyTo, realMail, subje
               Error | sgMail.ResponseError,
               [sgMail.ClientResponse, Record<string, unknown>]
             >(
-              cb =>
+              (cb) =>
                 void sgMail.send(renderedMsg, false, (err, result) =>
-                  err ?
-                    cb(Effect.fail(err)) :
-                    cb(Effect(result)))
+                  err
+                    ? cb(Effect.fail(err))
+                    : cb(Effect(result)))
             )
           )
 
@@ -55,7 +55,8 @@ const makeLiveSendgrid = ({ apiKey, defaultFrom, defaultReplyTo, realMail, subje
  * @tsplus static Emailer.Ops LiveSendgrid
  */
 export function LiveSendgrid(config: Config<SendgridConfig>) {
-  return config.config
+  return config
+    .config
     .flatMap(makeLiveSendgrid)
     .toLayer(Emailer)
 }
@@ -86,10 +87,10 @@ export function renderMessage(forceFake: boolean) {
  */
 export function isTestAddress(to: EmailData) {
   return (
-    (typeof to === "string" && to.toLowerCase().endsWith(".test")) ||
-    (typeof to === "object" &&
-      "email" in to &&
-      to.email.toLowerCase().endsWith(".test"))
+    (typeof to === "string" && to.toLowerCase().endsWith(".test"))
+    || (typeof to === "object"
+      && "email" in to
+      && to.email.toLowerCase().endsWith(".test"))
   )
 }
 
@@ -108,7 +109,7 @@ const eq = Equivalence.string.contramap((to: { name?: string; email: string } |
 function renderFakeIfTest(addr: EmailData | EmailData[], makeId: () => number) {
   return Array.isArray(addr)
     ? addr
-      .map(x => (isTestAddress(x) ? renderFake(x, makeId) : x))
+      .map((x) => (isTestAddress(x) ? renderFake(x, makeId) : x))
       .uniq(eq)
       .toArray
     : isTestAddress(addr)

package/_src/services/Emailer/fake.ts

@@ -1,7 +1,8 @@
 import { pretty } from "@effect-app/prelude/utils"
 import { Emailer } from "./service.js"
 
-const makeFake = Effect.logDebug("FAKE Emailer Service enabled")
+const makeFake = Effect
+  .logDebug("FAKE Emailer Service enabled")
   .map((): Emailer => ({
     sendMail(msg) {
       return Effect.logDebug(`Fake send mail`).logAnnotate("msg", pretty(msg))

package/_src/services/Operations/live.ts

@@ -4,7 +4,7 @@ import type { OperationProgress } from "@effect-app/prelude/Operations"
 import { Failure, Operation, OperationId, Success } from "@effect-app/prelude/Operations"
 import { Operations } from "./service.js"
 
-const reportAppError = reportError(cause => new RequestException(cause))
+const reportAppError = reportError((cause) => new RequestException(cause))
 
 const make = Effect.sync(() => {
   const ops = new Map<OperationId, Operation>()
@@ -12,7 +12,8 @@ const make = Effect.sync(() => {
 
   const cleanup = Effect.sync(() => {
     const before = new Date().subHours(1)
-    ops.entries()
+    ops
+      .entries()
       .toChunk
       .forEach(([id, op]) => {
         const lastChanged = Option.fromNullable(op.updatedAt).getOrElse(() => op.createdAt)
@@ -31,7 +32,7 @@ const make = Effect.sync(() => {
     return Effect(Option.fromNullable(ops.get(id)))
   }
   function finishOp(id: OperationId, exit: Exit<unknown, unknown>) {
-    return findOp(id).flatMap(_ =>
+    return findOp(id).flatMap((_) =>
       Effect.sync(() => {
         if (_.isNone()) {
           throw new Error("Not found")
@@ -46,18 +47,22 @@ const make = Effect.sync(() => {
                 ? LongString("Interrupted")
                 : exit.cause.isDie()
                 ? LongString("Unknown error")
-                : exit.cause.failureOption.flatMap(_ =>
-                  typeof _ === "object" && _ !== null && "message" in _ && LongString.Guard(_.message)
-                    ? Option(_.message)
-                    : Option.none
-                ).value ?? null
+                : exit
+                  .cause
+                  .failureOption
+                  .flatMap((_) =>
+                    typeof _ === "object" && _ !== null && "message" in _ && LongString.Guard(_.message)
+                      ? Option(_.message)
+                      : Option.none
+                  )
+                  .value ?? null
             })
         })
       })
     )
   }
   function update(id: OperationId, progress: OperationProgress) {
-    return findOp(id).flatMap(_ =>
+    return findOp(id).flatMap((_) =>
       Effect.sync(() => {
         if (_.isNone()) {
           throw new Error("Not found")
@@ -69,7 +74,7 @@ const make = Effect.sync(() => {
   return Operations.make({
     cleanup,
     register: makeOp
-      .tap(id =>
+      .tap((id) =>
         Effect.logAnnotateScoped("operationId", id)
           > addOp(id).acquireRelease(
             (_, exit) => finishOp(id, exit)
@@ -81,9 +86,10 @@ const make = Effect.sync(() => {
   })
 })
 
-const cleanupLoop = Operations.flatMap(_ => _.cleanup)
+const cleanupLoop = Operations
+  .flatMap((_) => _.cleanup)
   .exit
-  .flatMap(_ => {
+  .flatMap((_) => {
     if (_.isSuccess()) {
       return Effect.unit
     } else {