@effect-app/infra 0.198.1 → 0.199.0

package/src/logger/jsonLogger.ts

@@ -1,3 +1,4 @@
+import { Cause, FiberId, HashMap, List, Logger, Option } from "effect-app"
 import { getRequestContext } from "./shared.js"
 
 export const jsonLogger = Logger.make<unknown, void>(
@@ -10,12 +11,12 @@ export const jsonLogger = Logger.make<unknown, void>(
     const data = {
       timestamp: now,
       level: logLevel.label,
-      fiber: fiberId.threadName,
+      fiber: FiberId.threadName(fiberId),
       message,
-      request: c.value,
-      cause: cause != null && cause != Cause.empty ? cause.pretty : undefined,
-      spans: spans.map((_) => ({ label: _.label, timing: nowMillis - _.startTime })).toArray,
-      annotations: annotations.size > 0
+      request: Option.getOrUndefined(c),
+      cause: cause != null && cause != Cause.empty ? Cause.pretty(cause) : undefined,
+      spans: List.map(spans, (_) => ({ label: _.label, timing: nowMillis - _.startTime })).pipe(List.toArray),
+      annotations: HashMap.size(annotations) > 0
         ? [...annotations].reduce((prev, [k, v]) => {
           prev[k] = v
           return prev

package/src/logger/logFmtLogger.ts

@@ -1,23 +1,22 @@
+import { HashMap, Logger, Option } from "effect-app"
 import { getRequestContext } from "./shared.js"
 
 export const logfmtLogger = Logger.make<unknown, void>(
   (_) => {
     let { annotations } = _
     const c = getRequestContext(_.context)
-    const requestContext = c.value
+    const requestContext = Option.getOrUndefined(c)
     if (requestContext && requestContext.name !== "_root_") {
       annotations = HashMap.make(...[
         ...annotations,
-        ...{
+        ...Object.entries({
           "request.root.id": requestContext.rootId,
           "request.id": requestContext.id,
           "request.name": requestContext.name,
           "request.namespace": requestContext.namespace,
           "request.locale": requestContext.locale,
           ...(requestContext.userProfile?.sub ? { "request.user.sub": requestContext.userProfile.sub } : {})
-        }
-          .$$
-          .entries
+        })
       ])
     }
     const formatted = Logger.logfmtLogger.log({ ..._, annotations })

package/src/logger/shared.ts

@@ -1,14 +1,15 @@
 import { RuntimeFlags } from "effect"
+import { Context, FiberRef, Option, Runtime } from "effect-app"
 import * as FiberRefs from "effect/FiberRefs"
 import { RequestContextContainer } from "../services/RequestContextContainer.js"
 
 export function getRequestContext(fiberRefs: FiberRefs.FiberRefs) {
   const context = FiberRefs.getOrDefault(fiberRefs, FiberRef.currentContext)
-  const a = context.getOption(RequestContextContainer)
-  const c = a.map((_) => {
+  const a = Context.getOption(context, RequestContextContainer)
+  const c = Option.map(a, (_) => {
     // TODO: perhaps a litle expensive?
     const rt = Runtime.make({ context, fiberRefs, runtimeFlags: RuntimeFlags.none })
-    return rt.runSync(_.requestContext)
+    return Runtime.runSync(rt)(_.requestContext)
   })
   return c
 }

package/src/rateLimit.ts

@@ -23,6 +23,10 @@
 //   }
 // }
 
+import type { Semaphore } from "@effect-app/core/Effect"
+import type { Duration, NonEmptyArray } from "effect-app"
+import { Effect, ReadonlyArray } from "effect-app"
+
 /**
  * Executes the specified effect, acquiring the specified number of permits
  * immediately before the effect begins execution and releasing them
@@ -38,14 +42,12 @@ export function SEM_withPermitsDuration(permits: number, duration: Duration) {
       Effect.uninterruptibleMask(
         (restore) =>
           restore(self.take(permits))
-            .andThen(
+            .pipe(Effect.andThen(
               restore(effect)
-                .ensuring(
-                  self
-                    .release(permits)
-                    .delay(duration)
-                )
-            )
+                .pipe(Effect.ensuring(
+                  Effect.delay(self.release(permits), duration)
+                ))
+            ))
       )
   }
 }
@@ -60,15 +62,14 @@ export function batchPar<R, E, A, R2, E2, A2, T>(
   forEachBatch: (a: NonEmptyArray<A>, i: number) => Effect<A2, E2, R2>
 ) {
   return (items: Iterable<T>) =>
-    items
-      .chunk(n)
-      .forEachEffect(
-        (_, i) =>
-          _
-            .forEachEffect((_, j) => forEachItem(_, j, i), { concurrency: "inherit" })
-            .flatMap((_) => forEachBatch(_ as NonEmptyArray<A>, i)),
-        { concurrency: "inherit" }
-      )
+    Effect.forEach(
+      ReadonlyArray.chunk_(items, n),
+      (_, i) =>
+        Effect
+          .forEach(_, (_, j) => forEachItem(_, j, i), { concurrency: "inherit" })
+          .pipe(Effect.flatMap((_) => forEachBatch(_ as NonEmptyArray<A>, i))),
+      { concurrency: "inherit" }
+    )
 }
 
 /**
@@ -81,13 +82,13 @@ export function batch<R, E, A, R2, E2, A2, T>(
   forEachBatch: (a: NonEmptyArray<A>, i: number) => Effect<A2, E2, R2>
 ) {
   return (items: Iterable<T>) =>
-    items
-      .chunk(n)
-      .forEachEffect((_, i) =>
-        _
-          .forEachEffect((_, j) => forEachItem(_, j, i), { concurrency: "inherit" })
-          .flatMap((_) => forEachBatch(_ as NonEmptyArray<A>, i))
-      )
+    Effect.forEach(
+      ReadonlyArray.chunk_(items, n),
+      (_, i) =>
+        Effect
+          .forEach(_, (_, j) => forEachItem(_, j, i), { concurrency: "inherit" })
+          .pipe(Effect.flatMap((_) => forEachBatch(_ as NonEmptyArray<A>, i)))
+    )
 }
 
 // /**
@@ -117,20 +118,22 @@ export function batch<R, E, A, R2, E2, A2, T>(
 
 export function naiveRateLimit(
   n: number,
-  d: DUR
+  d: Duration
 ) {
   return <T>(items: Iterable<T>) => (<R, E, A, R2, E2, A2>(
     forEachItem: (i: T) => Effect<A, E, R>,
     forEachBatch: (a: A[]) => Effect<A2, E2, R2>
   ) =>
-    items
-      .chunk(n)
-      .forEachEffect((batch, i) =>
-        ((i === 0) ? Effect.unit : Effect.sleep(d))
-          .zipRight(
-            batch
-              .forEachEffect(forEachItem, { concurrency: n })
-              .flatMap(forEachBatch)
-          )
-      ))
+    Effect.forEach(
+      ReadonlyArray.chunk_(items, n),
+      (batch, i) =>
+        ((i === 0)
+          ? Effect.unit
+          : Effect.sleep(d))
+          .pipe(Effect.zipRight(
+            Effect
+              .forEach(batch, forEachItem, { concurrency: n })
+              .pipe(Effect.flatMap(forEachBatch))
+          ))
+    ))
 }

package/src/services/Emailer/Sendgrid.ts

@@ -1,13 +1,14 @@
 import { dropUndefinedT } from "@effect-app/core/utils"
 import type { EmailData } from "@sendgrid/helpers/classes/email-address.js"
 import sgMail from "@sendgrid/mail"
+import { Effect, Equivalence, ReadonlyArray, Secret } from "effect-app"
 import { inspect } from "util"
 import { Emailer } from "./service.js"
 import type { EmailMsg, EmailMsgOptionalFrom, SendgridConfig } from "./service.js"
 
 const makeSendgrid = ({ apiKey, defaultFrom, defaultReplyTo, realMail, subjectPrefix }: SendgridConfig) =>
   Effect.sync(() => {
-    sgMail.setApiKey(apiKey.value)
+    sgMail.setApiKey(Secret.value(apiKey))
 
     return new Emailer({
       sendMail(msg_: EmailMsgOptionalFrom) {
@@ -21,7 +22,7 @@ const makeSendgrid = ({ apiKey, defaultFrom, defaultReplyTo, realMail, subjectPr
 
           const renderedMsg_ = render(msg)
           const renderedMsg = { ...renderedMsg_, subject: `${subjectPrefix}${renderedMsg_.subject}` }
-          yield* $(Effect.logDebug("Sending email").annotateLogs("msg", inspect(renderedMsg, false, 5)))
+          yield* $(Effect.logDebug("Sending email").pipe(Effect.annotateLogs("msg", inspect(renderedMsg, false, 5))))
 
           const ret = yield* $(
             Effect.async<[sgMail.ClientResponse, Record<string, unknown>], Error | sgMail.ResponseError>(
@@ -52,8 +53,7 @@ const makeSendgrid = ({ apiKey, defaultFrom, defaultReplyTo, realMail, subjectPr
  * @tsplus static Emailer.Ops SendgridLayer
  */
 export function Sendgrid(config: SendgridConfig) {
-  return makeSendgrid(config)
-    .toLayer(Emailer)
+  return Emailer.toLayer(makeSendgrid(config))
 }
 
 /**
@@ -97,18 +97,20 @@ function renderFake(addr: EmailData | EmailData[], makeId: () => number) {
     email: `test+${makeId()}@nomizz.com`
   }
 }
-const eq = Equivalence.string.mapInput((to: { name?: string; email: string } | string) =>
-  typeof to === "string" ? to.toLowerCase() : to.email.toLowerCase()
+const eq = Equivalence.mapInput(
+  Equivalence.string,
+  (to: { name?: string; email: string } | string) => typeof to === "string" ? to.toLowerCase() : to.email.toLowerCase()
 )
 
 // TODO: should just not add any already added email address
 // https://stackoverflow.com/a/53603076/11595834
 function renderFakeIfTest(addr: EmailData | EmailData[], makeId: () => number) {
   return Array.isArray(addr)
-    ? addr
-      .map((x) => (isTestAddress(x) ? renderFake(x, makeId) : x))
-      .dedupeWith(eq)
-      .toArray
+    ? ReadonlyArray.dedupeWith(
+      addr
+        .map((x) => (isTestAddress(x) ? renderFake(x, makeId) : x)),
+      eq
+    )
     : isTestAddress(addr)
     ? renderFake(addr, makeId)
     : addr

package/src/services/Emailer/fake.ts

@@ -1,17 +1,20 @@
+import { Effect, Layer } from "effect-app"
 import { pretty } from "effect-app/utils"
 import { Emailer } from "./service.js"
 
 const makeFake = Effect
   .logDebug("FAKE Emailer Service enabled")
-  .map(() =>
+  .pipe(Effect.map(() =>
     new Emailer({
       sendMail(msg) {
-        return Effect.logDebug(`Fake send mail`).annotateLogs("msg", pretty(msg))
+        return Effect
+          .logDebug(`Fake send mail`)
+          .pipe(Effect.annotateLogs("msg", pretty(msg)))
       }
     })
-  )
+  ))
 
 /**
  * @tsplus static Emailer.Ops Fake
  */
-export const FakeSendgrid = makeFake.toLayer(Emailer)
+export const FakeSendgrid = Layer.effect(Emailer, makeFake)

package/src/services/Emailer/service.ts

@@ -1,6 +1,9 @@
+import type { Email, NonEmptyString255 } from "@effect-app/schema"
 import type { MailContent, MailData } from "@sendgrid/helpers/classes/mail.js"
 import type { ResponseError } from "@sendgrid/mail"
 import type sgMail from "@sendgrid/mail"
+import type { Effect, NonEmptyReadonlyArray, Secret } from "effect-app"
+import { TagClassId } from "effect-app/service"
 
 /**
  * @tsplus type Emailer
@@ -15,7 +18,7 @@ export interface SendgridConfig {
   subjectPrefix: string
   realMail: boolean
   defaultFrom: Email | { name?: NonEmptyString255; email: Email }
-  apiKey: Secret
+  apiKey: Secret.Secret
 }
 export type EmailMsg = sgMail.MailDataRequired
 export type EmailTemplateMsg = MailData & { templateId: string }

package/src/services/Operations/live.ts

@@ -1,4 +1,8 @@
+import { annotateLogscoped } from "@effect-app/core/Effect"
 import { reportError } from "@effect-app/infra/errorReporter"
+import { NonEmptyString2k } from "@effect-app/schema"
+import { subHours } from "date-fns"
+import { Cause, copy, Duration, Effect, Exit, Layer, Option, S, Schedule } from "effect-app"
 import type { OperationProgress } from "effect-app/Operations"
 import { Failure, Operation, OperationId, Success } from "effect-app/Operations"
 import { Operations } from "./service.js"
@@ -11,18 +15,17 @@ const make = Effect.sync(() => {
 
   const cleanup = Effect
     .sync(() => {
-      const before = new Date().subHours(1)
-      ops
-        .entries()
-        .toChunk
+      const before = subHours(new Date(), 1)
+      ;[...ops
+        .entries()]
         .forEach(([id, op]) => {
-          const lastChanged = Option.fromNullable(op.updatedAt).getOrElse(() => op.createdAt)
+          const lastChanged = Option.fromNullable(op.updatedAt).pipe(Option.getOrElse(() => op.createdAt))
           if (lastChanged < before) {
             ops.delete(id)
           }
         })
     })
-    .withSpan("Operations.cleanup")
+    .pipe(Effect.withSpan("Operations.cleanup"))
 
   function addOp(id: OperationId) {
     return Effect.sync(() => {
@@ -33,57 +36,56 @@ const make = Effect.sync(() => {
     return Effect.sync(() => Option.fromNullable(ops.get(id)))
   }
   function finishOp(id: OperationId, exit: Exit<unknown, unknown>) {
-    return findOp(id).flatMap((_) =>
+    return Effect.flatMap(findOp(id), (_) =>
       Effect.sync(() => {
-        if (_.isNone()) {
+        if (Option.isNone(_)) {
           throw new Error("Not found")
         }
-        ops.set(id, {
-          ..._.value,
-          updatedAt: new Date(),
-          result: exit.isSuccess()
-            ? new Success()
-            : new Failure({
-              message: exit.cause.isInterrupted()
-                ? NonEmptyString2k("Interrupted")
-                : exit.cause.isDie()
-                ? NonEmptyString2k("Unknown error")
-                : exit
-                  .cause
-                  .failureOption
-                  .flatMap((_) =>
-                    typeof _ === "object" && _ !== null && "message" in _ && NonEmptyString2k.is(_.message)
-                      ? Option.some(_.message)
-                      : Option.none()
-                  )
-                  .value ?? null
-            })
-        })
-      })
-    )
+        ops.set(
+          id,
+          copy(_.value, {
+            updatedAt: new Date(),
+            result: Exit.isSuccess(exit)
+              ? new Success()
+              : new Failure({
+                message: Cause.isInterrupted(exit.cause)
+                  ? NonEmptyString2k("Interrupted")
+                  : Cause.isDie(exit.cause)
+                  ? NonEmptyString2k("Unknown error")
+                  : Cause
+                    .failureOption(exit.cause)
+                    .pipe(
+                      Option.flatMap((_) =>
+                        typeof _ === "object" && _ !== null && "message" in _ && S.is(NonEmptyString2k)(_.message)
+                          ? Option.some(_.message)
+                          : Option.none()
+                      ),
+                      Option.getOrNull
+                    )
+              })
+          })
+        )
+      }))
   }
   function update(id: OperationId, progress: OperationProgress) {
-    return findOp(id).flatMap((_) =>
+    return Effect.flatMap(findOp(id), (_) =>
       Effect.sync(() => {
-        if (_.isNone()) {
+        if (Option.isNone(_)) {
           throw new Error("Not found")
         }
-        ops.set(id, { ..._.value, updatedAt: new Date(), progress })
-      })
-    )
+        ops.set(id, copy(_.value, { updatedAt: new Date(), progress }))
+      }))
   }
   return new Operations({
     cleanup,
-    register: makeOp
-      .tap((id) =>
-        Effect
-          .annotateLogscoped("operationId", id)
-          .andThen(
-            addOp(id).acquireRelease(
-              (_, exit) => finishOp(id, exit)
-            )
-          )
-      ),
+    register: Effect.tap(
+      makeOp,
+      (id) =>
+        Effect.andThen(
+          annotateLogscoped("operationId", id),
+          Effect.acquireRelease(addOp(id), (_, exit) => finishOp(id, exit))
+        )
+    ),
 
     find: findOp,
     update
@@ -91,21 +93,26 @@ const make = Effect.sync(() => {
 })
 
 const cleanupLoop = Operations
-  .flatMap((_) => _.cleanup)
-  .exit
-  .flatMap((_) => {
-    if (_.isSuccess()) {
-      return Effect.unit
-    } else {
-      return reportAppError(_.cause)
-    }
-  })
-  .schedule(Schedule.fixed(Duration.minutes(1)))
-  .forkScoped
+  .pipe(
+    Effect.flatMap((_) => _.cleanup),
+    Effect.exit,
+    Effect
+      .flatMap((_) => {
+        if (Exit.isSuccess(_)) {
+          return Effect.unit
+        } else {
+          return reportAppError(_.cause)
+        }
+      }),
+    Effect.schedule(Schedule.fixed(Duration.minutes(1))),
+    Effect.forkScoped
+  )
 
 /**
  * @tsplus static Operations.Ops Live
  */
 export const Live = cleanupLoop
-  .toLayerScopedDiscard
-  .provideMerge(make.toLayer(Operations))
+  .pipe(
+    Layer.scopedDiscard,
+    Layer.provideMerge(Layer.effect(Operations, make))
+  )

package/src/services/Operations/service.ts

@@ -1,5 +1,9 @@
+import type { Option } from "effect-app"
+import { Effect } from "effect-app"
 import type { Operation, OperationId, OperationProgress } from "effect-app/Operations"
+import { TagClassId } from "effect-app/service"
 import * as Scope from "effect/Scope"
+import { forkDaemonReportRequestUnexpected } from "../../api/reportError.js"
 
 /**
  * @tsplus type Operations
@@ -21,41 +25,43 @@ export class Operations extends TagClassId("effect-app/Operations")<Operations,
  * @tsplus getter effect/io/Effect forkOperation
  */
 export function forkOperation<R, E, A>(self: Effect<A, E, R>) {
-  return Operations.flatMap(
-    (Operations) =>
-      Scope
-        .make()
-        .flatMap((scope) =>
-          Operations
-            .register
-            .extend(scope)
-            .tap(() => self.use(scope).forkDaemonReportRequestUnexpected)
-        )
-  )
+  return Effect.flatMap(Operations, (Operations) =>
+    Effect.flatMap(
+      Scope.make(),
+      (scope) =>
+        Operations
+          .register
+          .pipe(
+            Scope.extend(scope),
+            Effect
+              .tap(() => forkDaemonReportRequestUnexpected(Scope.use(self, scope)))
+          )
+    ))
 }
 
 /**
  * @tsplus getter function forkOperation
  */
 export function forkOperationFunction<R, E, A, Inp>(fnc: (inp: Inp) => Effect<A, E, R>) {
-  return (inp: Inp) => fnc(inp).forkOperation
+  return (inp: Inp) => fnc(inp).pipe(forkOperation)
 }
 
 /**
  * @tsplus static effect/io/Effect.Ops forkOperation
  */
 export function forkOperation2<R, E, A>(self: (opId: OperationId) => Effect<A, E, R>) {
-  return Operations.flatMap(
-    (Operations) =>
-      Scope
-        .make()
-        .flatMap((scope) =>
-          Operations
-            .register
-            .extend(scope)
-            .tap((id) => self(id).use(scope).forkDaemonReportRequestUnexpected)
-        )
-  )
+  return Effect.flatMap(Operations, (Operations) =>
+    Effect.flatMap(
+      Scope.make(),
+      (scope) =>
+        Operations
+          .register
+          .pipe(
+            Scope.extend(scope),
+            Effect
+              .tap((id) => forkDaemonReportRequestUnexpected(Scope.use(self(id), scope)))
+          )
+    ))
 }
 
 /**
@@ -65,16 +71,17 @@ export function forkOperationWithEffect<R, R2, E, E2, A, A2>(
   self: (id: OperationId) => Effect<A, E, R>,
   fnc: (id: OperationId) => Effect<A2, E2, R2>
 ) {
-  return Operations.flatMap(
-    (Operations) =>
+  return Effect.flatMap(Operations, (Operations) =>
+    Effect.flatMap(
       Scope
-        .make()
-        .flatMap((scope) =>
-          Operations
-            .register
-            .extend(scope)
-            .tap((opId) => self(opId).use(scope).forkDaemonReportRequestUnexpected)
-            .tap((opId) => fnc(opId).interruptible.forkScoped.extend(scope))
-        )
-  )
+        .make(),
+      (scope) =>
+        Operations
+          .register
+          .pipe(
+            Scope.extend(scope),
+            Effect.tap((opId) => forkDaemonReportRequestUnexpected(Scope.use(self(opId), scope))),
+            Effect.tap((opId) => Effect.interruptible(fnc(opId)).pipe(Effect.forkScoped, Scope.extend(scope)))
+          )
+    ))
 }

package/src/services/QueueMaker/errors.ts

@@ -1,4 +1,5 @@
 import { reportError } from "@effect-app/infra/errorReporter"
+import { Cause, Effect, Exit } from "effect-app"
 
 const reportQueueError_ = reportError("Queue")
 
@@ -15,7 +16,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<A, E, R>) {
-  return self.tapErrorCause(reportNonInterruptedFailureCause({})).fork.daemonChildren
+  return self.pipe(Effect.tapErrorCause(reportNonInterruptedFailureCause({})), Effect.fork, Effect.daemonChildren)
 }
 
 export const reportFatalQueueError = reportError(
@@ -25,20 +26,23 @@ export const reportFatalQueueError = reportError(
 export function reportNonInterruptedFailure(context?: Record<string, unknown>) {
   const report = reportNonInterruptedFailureCause(context)
   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)
-        })
-      )
+    inp.pipe(
+      Effect
+        .exit,
+      Effect
+        .flatMap((result) =>
+          Exit.match(result, {
+            onFailure: (cause) => Effect.map(report(cause), () => result),
+            onSuccess: () => Effect.sync(() => result)
+          })
+        )
+    )
 }
 
 export function reportNonInterruptedFailureCause(context?: Record<string, unknown>) {
   return <E>(cause: Cause<E>): Effect<void> => {
-    if (cause.isInterrupted()) {
-      return (cause as Cause<never>).failCause
+    if (Cause.isInterrupted(cause)) {
+      return Effect.failCause(cause as Cause<never>)
     }
     return reportQueueError(cause, context)
   }