@effect-app/infra 0.73.1 → 0.74.0

package/_src/api/express/schema/routing.ts

@@ -100,34 +100,34 @@ export function makeFromSchema<ResA>(
   // TODO EffectOption.fromNullable(Req.Headers).flatMapOpt(jsonSchema)
   // TODO: use the path vs body etc serialisation also in the Client.
   const makeReqQuerySchema = Effect(Option.fromNullable(Req.Query)).flatMap((_) =>
-    _.match(
-      () => Effect(Option.none),
-      (_) => jsonSchema(_).map(Option.some)
-    )
+    _.match({
+      onNone: () => Effect(Option.none),
+      onSome: (_) => jsonSchema(_).map(Option.some)
+    })
   )
   const makeReqHeadersSchema = Effect(Option.fromNullable(Req.Headers)).flatMap((_) =>
-    _.match(
-      () => Effect(Option.none),
-      (_) => jsonSchema(_).map(Option.some)
-    )
+    _.match({
+      onNone: () => Effect(Option.none),
+      onSome: (_) => jsonSchema(_).map(Option.some)
+    })
   )
   const makeReqCookieSchema = Effect(Option.fromNullable(Req.Cookie)).flatMap((_) =>
-    _.match(
-      () => Effect(Option.none),
-      (_) => jsonSchema(_).map(Option.some)
-    )
+    _.match({
+      onNone: () => Effect(Option.none),
+      onSome: (_) => jsonSchema(_).map(Option.some)
+    })
   )
   const makeReqPathSchema = Effect(Option.fromNullable(Req.Path)).flatMap((_) =>
-    _.match(
-      () => Effect(Option.none),
-      (_) => jsonSchema(_).map(Option.some)
-    )
+    _.match({
+      onNone: () => Effect(Option.none),
+      onSome: (_) => jsonSchema(_).map(Option.some)
+    })
   )
   const makeReqBodySchema = Effect(Option.fromNullable(Req.Body)).flatMap((_) =>
-    _.match(
-      () => Effect(Option.none),
-      (_) => jsonSchema(_).map(Option.some)
-    )
+    _.match({
+      onNone: () => Effect(Option.none),
+      onSome: (_) => jsonSchema(_).map(Option.some)
+    })
   )
   // const makeReqSchema = schema(Req)
 

package/_src/api/reportError.ts

@@ -15,17 +15,17 @@ export class FatalMainException<E> extends CauseException<E> {
 const reportMainError_ = reportError((cause) => new FatalMainException(cause))
 
 export const reportMainError = <E>(cause: Cause<E>, extras?: Record<string, unknown> | undefined) =>
-  Debug.untraced(() => reportMainError_(cause, extras))
+  reportMainError_(cause, extras)
 
 const reportRequestError_ = reportError((cause) => new RequestException(cause))
 
 export const reportRequestError = <E>(cause: Cause<E>, extras?: Record<string, unknown> | undefined) =>
-  Debug.untraced(() => reportRequestError_(cause, extras))
+  reportRequestError_(cause, extras)
 
 const logRequestError_ = logError((cause) => new RequestException(cause))
 
 export const logRequestError = <E>(cause: Cause<E>, extras?: Record<string, unknown> | undefined) =>
-  Debug.untraced(() => logRequestError_(cause, extras))
+  logRequestError_(cause, extras)
 
 /**
  * Forks the effect into a new fiber attached to the global scope. Because the
@@ -37,12 +37,10 @@ export const logRequestError = <E>(cause: Cause<E>, extras?: Record<string, unkn
  * @tsplus getter effect/io/Effect forkDaemonReportRequest
  */
 export function forkDaemonReportRequest<R, E, A>(self: Effect<R, E, A>) {
-  return Debug.untraced(() =>
-    self
-      .tapErrorCause(reportRequestError)
-      .fork
-      .daemonChildren
-  )
+  return self
+    .tapErrorCause(reportRequestError)
+    .fork
+    .daemonChildren
 }
 
 /**
@@ -55,14 +53,12 @@ export function forkDaemonReportRequest<R, E, A>(self: Effect<R, E, A>) {
  * @tsplus getter effect/io/Effect forkDaemonReportRequestUnexpected
  */
 export function forkDaemonReportRequestUnexpected<R, E, A>(self: Effect<R, E, A>) {
-  return Debug.untraced(() =>
-    self
-      .tapErrorCause((cause) =>
-        cause.isInterruptedOnly() || cause.isDie()
-          ? reportRequestError(cause)
-          : logRequestError(cause)
-      )
-      .fork
-      .daemonChildren
-  )
+  return self
+    .tapErrorCause((cause) =>
+      cause.isInterruptedOnly() || cause.isDie()
+        ? reportRequestError(cause)
+        : logRequestError(cause)
+    )
+    .fork
+    .daemonChildren
 }

package/_src/api/routing.ts

@@ -309,77 +309,77 @@ 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)
-        })
-        .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
-                  })
-                  .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
-                      // 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
-                )
+    return 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.annotateLogs({
+                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
               })
             )
-            .tapErrorCause((cause) =>
-              Effect
-                .allPar(
+          )
+          .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) =>
+                  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
+                    // 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
+              .all(
+                [
                   Effect(res.status(500).send()),
                   Effect(
                     reportRequestError(cause, {
@@ -390,11 +390,11 @@ export function makeRequestHandler<
                   Effect.suspend(() => {
                     const headers = res.getHeaders()
                     return Effect
-                      .logErrorCauseMessage(
+                      .logError(
                         "Finished request",
                         cause
                       )
-                      .apply(Effect.logAnnotates({
+                      .apply(Effect.annotateLogs({
                         method: req.method,
                         path: req.originalUrl,
                         statusCode: res.statusCode.toString(),
@@ -415,30 +415,31 @@ export function makeRequestHandler<
                           .pretty
                       }))
                   })
-                )
-                .tapErrorCause((cause) => Effect(console.error("Error occurred while reporting error", cause)))
-            )
-            .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
-                  }))
-                })
-            )
-            .logSpan("request")
-            .provideService(RequestContextContainer, new RequestContextContainerImpl(requestContext)) // otherwise external error reporter breaks.
-        )
-    )
+                ],
+                { concurrency: "inherit" }
+              )
+              .tapErrorCause((cause) => Effect(console.error("Error occurred while reporting error", cause)))
+          )
+          .tap(() =>
+            RequestSettings
+              .get
+              .flatMap((s) => {
+                const headers = res.getHeaders()
+                return Effect.logInfo("Finished request").apply(Effect.annotateLogs({
+                  method: req.method,
+                  path: req.originalUrl,
+                  statusCode: res.statusCode.toString(),
+                  ...s.verbose
+                    ? {
+                      resHeaders: headers.$$.pretty
+                    }
+                    : undefined
+                }))
+              })
+          )
+          .withSpan("request")
+          .provideService(RequestContextContainer, new RequestContextContainerImpl(requestContext)) // otherwise external error reporter breaks.
+      )
   }
 }
 

package/_src/api/setupRequest.ts

@@ -6,12 +6,10 @@ import { RequestContextContainer, RequestContextContainerImpl } from "../service
  * @tsplus fluent effect/io/Effect setupRequestFromWith
  */
 export function setupReq3<R, E, A>(self: Effect<R, E, A>, name: string) {
-  return Debug.untraced(() =>
-    makeInternalRequestContext(name).flatMap((rc) =>
-      self
-        .logSpan("request")
-        .provideService(RequestContextContainer, new RequestContextContainerImpl(rc))
-    )
+  return makeInternalRequestContext(name).flatMap((rc) =>
+    self
+      .withSpan("request")
+      .provideService(RequestContextContainer, new RequestContextContainerImpl(rc))
   )
 }
 

package/_src/api/writeDocs.ts

@@ -8,7 +8,7 @@ export function writeOpenapiDocs(rdescs: Record<string, Record<string, RouteDesc
   return makeOpenApiSpecs(
     typedValuesOf(rdescs)
       .reduce((prev, cur) => prev.concat(typedValuesOf(cur)), [] as readonly RouteDescriptorAny[])
-      .sortWith(Order.string.contramap((a: RouteDescriptorAny) => a.path)),
+      .sortWith(Order.string.mapInput((a: RouteDescriptorAny) => a.path)),
     Plutus.info({
       title: "api",
       version: "X",

package/_src/errorReporter.ts

@@ -6,22 +6,20 @@ export function reportError<E, E2 extends CauseException<unknown>>(
   makeError: (cause: Cause<E>) => E2
 ) {
   return (cause: Cause<E>, extras?: Record<string, unknown>) =>
-    Debug.untraced(() =>
-      Effect.gen(function*($) {
-        if (cause.isInterrupted()) {
-          yield* $(Effect.logDebug("Interrupted").logAnnotate("extras", JSON.stringify(extras ?? {})))
-          return
-        }
-        const error = makeError(cause)
-        yield* $(reportSentry(error, extras))
-        yield* $(
-          cause.logErrorCause.logAnnotate(
-            "extras",
-            JSON.stringify({ ...extras, __error__: { _tag: error._tag, message: error.message } })
-          )
+    Effect.gen(function*($) {
+      if (cause.isInterrupted()) {
+        yield* $(Effect.logDebug("Interrupted").annotateLogs("extras", JSON.stringify(extras ?? {})))
+        return
+      }
+      const error = makeError(cause)
+      yield* $(reportSentry(error, extras))
+      yield* $(
+        cause.logError.annotateLogs(
+          "extras",
+          JSON.stringify({ ...extras, __error__: { _tag: error._tag, message: error.message } })
         )
-      })
-    )
+      )
+    })
 }
 
 function reportSentry<E2 extends CauseException<unknown>>(
@@ -42,21 +40,19 @@ export function logError<E, E2 extends CauseException<unknown>>(
   makeError: (cause: Cause<E>) => E2
 ) {
   return (cause: Cause<E>, extras?: Record<string, unknown>) =>
-    Debug.untraced(() =>
-      Effect.gen(function*($) {
-        if (cause.isInterrupted()) {
-          yield* $(Effect.logDebug("Interrupted").logAnnotate("extras", JSON.stringify(extras ?? {})))
-          return
-        }
-        const error = makeError(cause)
-        yield* $(
-          cause.logWarningCause.logAnnotate(
-            "extras",
-            JSON.stringify({ ...extras, __error__: { _tag: error._tag, message: error.message } })
-          )
+    Effect.gen(function*($) {
+      if (cause.isInterrupted()) {
+        yield* $(Effect.logDebug("Interrupted").annotateLogs("extras", JSON.stringify(extras ?? {})))
+        return
+      }
+      const error = makeError(cause)
+      yield* $(
+        cause.logWarning.annotateLogs(
+          "extras",
+          JSON.stringify({ ...extras, __error__: { _tag: error._tag, message: error.message } })
         )
-      })
-    )
+      )
+    })
 }
 
 export function captureException(error: unknown) {

package/_src/errors.ts

@@ -1,4 +1,4 @@
-import * as CausePretty from "@effect/io/internal_effect_untraced/cause-pretty"
+import * as CausePretty from "@effect/io/internal/cause"
 
 export class NotFoundError<T extends string = string> {
   public readonly _tag = "NotFoundError"

package/_src/instrument.ts

@@ -2,10 +2,9 @@
  * @tsplus fluent effect/io/Effect instrument
  */
 export function instr<R, E, A>(self: Effect<R, E, A>, name: string, properties?: Record<string, string>) {
-  return Debug.untraced(() =>
-    self
-      .tap(() => Effect.logDebug(`instrumented`).logAnnotate("properties", (properties || {}).$$.pretty))
-      .logSpan(name)
-  )
+  return self
+    .tap(() => Effect.logDebug(`instrumented`).annotateLogs("properties", (properties || {}).$$.pretty))
+    .withSpan(name)
+
   // trackMetric(name, time, properties))
 }

package/_src/logger/jsonLogger.ts

@@ -1,7 +1,8 @@
+import type { AnnotationValue } from "@effect/io/Logger"
 import { getRequestContext } from "./shared.js"
 
-export const jsonLogger = Logger.make<string, void>(
-  (fiberId, logLevel, message, cause, context, spans, annotations) => {
+export const jsonLogger = Logger.make<unknown, void>(
+  ({ annotations, cause, context, fiberId, logLevel, message, spans }) => {
     const now = new Date()
     const nowMillis = now.getTime()
 
@@ -14,14 +15,12 @@ export const jsonLogger = Logger.make<string, void>(
       message,
       request: c.value,
       cause: cause != null && cause != Cause.empty ? cause.pretty : undefined,
-      spans: Chunk.isNonEmpty(spans)
-        ? spans.map((_) => ({ label: _.label, timing: nowMillis - _.startTime })).toArray
-        : undefined,
+      spans: spans.map((_) => ({ label: _.label, timing: nowMillis - _.startTime })).toReadonlyArray,
       annotations: annotations.size > 0
         ? [...annotations].reduce((prev, [k, v]) => {
           prev[k] = v
           return prev
-        }, {} as Record<string, string>)
+        }, {} as Record<string, AnnotationValue>)
         : undefined
     }
 

package/_src/logger/logFmtLogger.ts

@@ -1,8 +1,9 @@
 import { getRequestContext } from "./shared.js"
 
-export const logfmtLogger = Logger.make<string, void>(
-  (fiberId, logLevel, message, cause, context, spans, annotations) => {
-    const c = getRequestContext(context)
+export const logfmtLogger = Logger.make<unknown, void>(
+  (_) => {
+    let { annotations } = _
+    const c = getRequestContext(_.context)
     const requestContext = c.value
     if (requestContext) {
       annotations = HashMap.make(...[
@@ -17,7 +18,7 @@ export const logfmtLogger = Logger.make<string, void>(
           .entries
       ])
     }
-    const formatted = Logger.logfmtLogger.log(fiberId, logLevel, message, cause, context, spans, annotations)
+    const formatted = Logger.logfmtLogger.log(_)
     globalThis.console.log(formatted)
   }
 )

package/_src/rateLimit.ts

@@ -60,10 +60,12 @@ export function batchPar<R, E, A, R2, E2, A2, T>(
   return (items: Iterable<T>) =>
     items
       .chunk(n)
-      .forEachEffectParWithIndex((_, i) =>
-        _
-          .forEachParWithIndex((_, j) => forEachItem(_, j, i))
-          .flatMap((_) => forEachBatch(_ as NonEmptyArray<A>, i))
+      .forEachEffect(
+        (_, i) =>
+          _
+            .forEachEffect((_, j) => forEachItem(_, j, i), { concurrency: "inherit" })
+            .flatMap((_) => forEachBatch(_ as NonEmptyArray<A>, i)),
+        { concurrency: "inherit" }
       )
 }
 
@@ -79,9 +81,9 @@ export function batch<R, E, A, R2, E2, A2, T>(
   return (items: Iterable<T>) =>
     items
       .chunk(n)
-      .forEachEffectWithIndex((_, i) =>
+      .forEachEffect((_, i) =>
         _
-          .forEachParWithIndex((_, j) => forEachItem(_, j, i))
+          .forEachEffect((_, j) => forEachItem(_, j, i), { concurrency: "inherit" })
           .flatMap((_) => forEachBatch(_ as NonEmptyArray<A>, i))
       )
 }
@@ -121,12 +123,11 @@ export function naiveRateLimit(
   ) =>
     items
       .chunk(n)
-      .forEachEffectWithIndex((batch, i) =>
+      .forEachEffect((batch, i) =>
         ((i === 0) ? Effect.unit : Effect.sleep(d))
           .zipRight(
             batch
-              .forEachEffectPar(forEachItem)
-              .withParallelism(n)
+              .forEachEffect(forEachItem, { concurrency: n })
               .flatMap(forEachBatch)
           )
       ))

package/_src/services/Emailer/Sendgrid.ts

@@ -20,7 +20,7 @@ const makeLiveSendgrid = ({ apiKey, defaultFrom, defaultReplyTo, realMail, subje
 
           const renderedMsg_ = render(msg)
           const renderedMsg = { ...renderedMsg_, subject: `${subjectPrefix}${renderedMsg_.subject}` }
-          yield* $(Effect.logDebug("Sending email").logAnnotate("msg", inspect(renderedMsg, false, 5)))
+          yield* $(Effect.logDebug("Sending email").annotateLogs("msg", inspect(renderedMsg, false, 5)))
 
           const ret = yield* $(
             Effect.async<
@@ -42,7 +42,7 @@ const makeLiveSendgrid = ({ apiKey, defaultFrom, defaultReplyTo, realMail, subje
           //     templateId: msg.templateId
           //   }
           // }
-          // yield* $(Effect.logDebug("Tracking email event").logAnnotate("event", event.$$.pretty))
+          // yield* $(Effect.logDebug("Tracking email event").annotateLogs("event", event.$$.pretty))
           // const { trackEvent } = yield* $(AiContextService)
           // trackEvent(event)
           return ret
@@ -100,7 +100,7 @@ function renderFake(addr: EmailData | EmailData[], makeId: () => number) {
     email: `test+${makeId()}@nomizz.com`
   }
 }
-const eq = Equivalence.string.contramap((to: { name?: string; email: string } | string) =>
+const eq = Equivalence.string.mapInput((to: { name?: string; email: string } | string) =>
   typeof to === "string" ? to.toLowerCase() : to.email.toLowerCase()
 )
 

package/_src/services/Emailer/fake.ts

@@ -5,7 +5,7 @@ const makeFake = Effect
   .logDebug("FAKE Emailer Service enabled")
   .map((): Emailer => ({
     sendMail(msg) {
-      return Effect.logDebug(`Fake send mail`).logAnnotate("msg", pretty(msg))
+      return Effect.logDebug(`Fake send mail`).annotateLogs("msg", pretty(msg))
     }
   }))
 

package/_src/services/Operations/live.ts

@@ -75,7 +75,7 @@ const make = Effect.sync((): Operations => {
     cleanup,
     register: makeOp
       .tap((id) =>
-        Effect.logAnnotateScoped("operationId", id)
+        Effect.annotateLogscoped("operationId", id)
           > addOp(id).acquireRelease(
             (_, exit) => finishOp(id, exit)
           )