@effect-app/infra 4.0.0-beta.25 → 4.0.0-beta.250

package/src/{api/ContextProvider.ts → ContextProvider.ts}

@@ -1,9 +1,13 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Effect, Layer, type NonEmptyReadonlyArray, pipe, type Scope, ServiceMap } from "effect-app"
+import type { NonEmptyReadonlyArray } from "effect-app/Array"
+import * as Context from "effect-app/Context"
+import * as Effect from "effect-app/Effect"
+import * as Layer from "effect-app/Layer"
+import { pipe } from "effect/Function"
+import type * as Scope from "effect/Scope"
 
 import { type HttpRouter } from "effect-app/http"
 import { type EffectGenUtils } from "effect-app/utils/gen"
-import { type Yieldable } from "effect/Effect"
 import { type ContextTagWithDefault, type GetContext, type LayerUtils, mergeContexts } from "./layerUtils.js"
 
 export interface ContextProviderId {
@@ -23,7 +27,7 @@ type TDepsArr<TDeps extends ReadonlyArray<any>> = {
   // E = never => the context provided cannot trigger errors
   // TODO: remove HttpLayerRouter.Provided - it's not even relevant outside of Http context, while ContextProviders are for anywhere. Only support Scope.Scope?
   //  _R extends HttpLayerRouter.Provided => the context provided can only have what HttpLayerRouter.Provided provides as requirements
-  ContextTagWithDefault.Base<Effect.Effect<ServiceMap.ServiceMap<infer _1>, never, infer _R>> // & { _tag: infer _2 }>
+  ContextTagWithDefault.Base<Effect.Effect<Context.Context<infer _1>, never, infer _R>> // & { _tag: infer _2 }>
     ? [_R] extends [HttpRouter.Provided] ? TDeps[K]
     : `HttpLayerRouter.Provided is the only requirement ${TDeps[K]["Service"][
       "_tag"
@@ -38,7 +42,7 @@ type TDepsArr<TDeps extends ReadonlyArray<any>> = {
       > // & { _tag: infer _3 }
     ) // [_YW] extends [never] if no yield* is used and just some context is returned
       ? [_YW] extends [never] ? TDeps[K]
-      : [_YW] extends [Yieldable<any, infer _2, never, infer _R>] ? [_R] extends [HttpRouter.Provided] ? TDeps[K]
+      : [_YW] extends [Effect.Effect<any, never, infer _R>] ? [_R] extends [HttpRouter.Provided] ? TDeps[K]
         : `HttpLayerRouter.Provided is the only requirement ${TDeps[K]["Service"][
           "_tag"
         ]}'s returned effect can have`
@@ -58,9 +62,9 @@ export const mergeContextProviders = <
     Effect.Effect<
       // we need to merge all contexts into one
       // v4: Service.Shape extracts the service value type (v3's Tag.Identifier)
-      ServiceMap.ServiceMap<GetContext<EffectGenUtils.Success<ServiceMap.Service.Shape<TDeps[number]>>>>,
+      Context.Context<GetContext<EffectGenUtils.Success<Context.Service.Shape<TDeps[number]>>>>,
       never,
-      EffectGenUtils.ServiceMap<ServiceMap.Service.Shape<TDeps[number]>>
+      EffectGenUtils.Context<Context.Service.Shape<TDeps[number]>>
     >,
     LayerUtils.GetLayersError<{ [K in keyof TDeps]: TDeps[K]["Default"] }>,
     LayerUtils.GetLayersSuccess<{ [K in keyof TDeps]: TDeps[K]["Default"] }>
@@ -78,14 +82,14 @@ export const mergeContextProviders = <
             handle: handle[Symbol.toStringTag] === "GeneratorFunction" ? Effect.fnUntraced(handle)() : handle
           }
         ))
-        // services are effects which return some ServiceMap.ServiceMap<...>
+        // services are effects which return some Context.Context<...>
         const context = yield* mergeContexts(services as any)
         return context
       })
   }) as any
 })
 
-// Effect Rpc Middleware: for single tag providing, we could use Provides, for providing ServiceMap or Layer (bad boy) we could use Wrap..
+// Effect Rpc Middleware: for single tag providing, we could use Provides, for providing Context or Layer (bad boy) we could use Wrap..
 export const ContextProvider = <
   ContextProviderA,
   MakeContextProviderE,
@@ -97,9 +101,8 @@ export const ContextProvider = <
     effect: Effect.Effect<
       | Effect.Effect<ContextProviderA, never, ContextProviderR>
       | (() => Generator<
-        Yieldable<any, any, never, ContextProviderR>,
-        ContextProviderA,
-        any
+        Effect.Effect<any, never, ContextProviderR>,
+        ContextProviderA
       >),
       MakeContextProviderE,
       MakeContextProviderR | Scope.Scope
@@ -107,7 +110,7 @@ export const ContextProvider = <
     dependencies?: Dependencies
   }
 ) => {
-  const ctx = ServiceMap.Service<
+  const ctx = Context.Service<
     ContextProviderId,
     Effect.Effect<ContextProviderA, never, ContextProviderR>
   >(
@@ -146,17 +149,17 @@ export const MergedContextProvider = <
     Effect.Effect<
       // we need to merge all contexts into one
       // v4: Service.Shape extracts the service value type (v3's Tag.Identifier)
-      ServiceMap.ServiceMap<GetContext<EffectGenUtils.Success<ServiceMap.Service.Shape<TDeps[number]>>>>,
+      Context.Context<GetContext<EffectGenUtils.Success<Context.Service.Shape<TDeps[number]>>>>,
       never,
-      EffectGenUtils.ServiceMap<ServiceMap.Service.Shape<TDeps[number]>>
+      EffectGenUtils.Context<Context.Service.Shape<TDeps[number]>>
     >,
     LayerUtils.GetLayersError<{ [K in keyof TDeps]: TDeps[K]["Default"] }>,
     // v4: Identifier here is correct — it's the nominal service identity for layer provide/exclude
     | Exclude<
-      ServiceMap.Service.Identifier<TDeps[number]>,
+      Context.Service.Identifier<TDeps[number]>,
       LayerUtils.GetLayersSuccess<{ [K in keyof TDeps]: TDeps[K]["Default"] }>
     >
     | LayerUtils.GetLayersContext<{ [K in keyof TDeps]: TDeps[K]["Default"] }>
   >
 
-export const EmptyContextProvider = ContextProvider({ effect: Effect.succeed(Effect.succeed(ServiceMap.empty())) })
+export const EmptyContextProvider = ContextProvider({ effect: Effect.succeed(Effect.succeed(Context.empty())) })

package/src/Emailer/Sendgrid.ts

@@ -1,63 +1,85 @@
-import type { EmailData } from "@sendgrid/helpers/classes/email-address.js"
 import type { MailContent } from "@sendgrid/helpers/classes/mail.js"
 import sgMail from "@sendgrid/mail"
-import { Array, Effect, Equivalence, Redacted } from "effect-app"
+import * as Array from "effect-app/Array"
+import * as Effect from "effect-app/Effect"
+import { type EmailData, Emailer, type EmailMsg, type EmailMsgOptionalFrom, SendMailError } from "effect-app/Emailer"
 import { dropUndefinedT } from "effect-app/utils"
+import * as Equivalence from "effect/Equivalence"
+import * as Redacted from "effect/Redacted"
 import { inspect } from "util"
 import { InfraLogger } from "../logger.js"
-import { Emailer, type EmailMsg, type EmailMsgOptionalFrom, type SendgridConfig, SendMailError } from "./service.js"
 
-const makeSendgrid = ({ apiKey, defaultFrom, defaultReplyTo, realMail, subjectPrefix }: SendgridConfig) =>
+export interface SendgridConfig {
+  defaultReplyTo?: EmailData
+  subjectPrefix: string
+  realMail: boolean
+  defaultFrom: EmailData
+  apiKey: Redacted.Redacted
+  /**
+   * Email address used for fake/test recipients. Use `{i}` as a placeholder for
+   * an auto-incrementing index to ensure uniqueness.
+   *
+   * @example "test+{i}@example.com"
+   */
+  fakeMailAddress: string
+}
+
+const makeSendgrid = (
+  { apiKey, defaultFrom, defaultReplyTo, fakeMailAddress, realMail, subjectPrefix }: SendgridConfig
+) =>
   Effect.sync(() => {
     sgMail.setApiKey(Redacted.value(apiKey))
 
     return Emailer.of({
-      sendMail: Effect.fn("Sendgrid.sendMail")(function*(msg_: EmailMsgOptionalFrom) {
-        const msg: EmailMsg = dropUndefinedT({
-          ...msg_,
-          from: msg_.from ?? defaultFrom,
-          replyTo: msg_.replyTo ?? (msg_.from ? undefined : defaultReplyTo)
-        })
-        const render = renderMessage(!realMail)
+      sendMail: Effect.fn("Emailer.sendMail", { attributes: { "messaging.system": "sendgrid" } })(
+        function*(msg_: EmailMsgOptionalFrom) {
+          const replyTo = msg_.replyTo ?? (msg_.from ? undefined : defaultReplyTo)
+          const msg = dropUndefinedT({
+            ...msg_,
+            from: msg_.from ?? defaultFrom,
+            replyTo
+          }) satisfies EmailMsg
+          const render = renderMessage(!realMail, fakeMailAddress)
 
-        const renderedMsg_ = render(msg)
-        const renderedMsg = {
-          ...renderedMsg_ as Omit<typeof renderedMsg_, "content">,
-          subject: `${subjectPrefix}${renderedMsg_.subject}`,
-          ..."content" in renderedMsg_
-            ? { content: [...renderedMsg_.content] as [MailContent, ...MailContent[]] }
-            : {}
-        }
-        yield* InfraLogger.logDebug("Sending email").pipe(Effect.annotateLogs("msg", inspect(renderedMsg, false, 5)))
+          const renderedMsg_ = render(msg)
+          const renderedMsg = {
+            ...renderedMsg_ as Omit<typeof renderedMsg_, "content">,
+            subject: `${subjectPrefix}${renderedMsg_.subject}`,
+            ..."content" in renderedMsg_
+              ? { content: [...renderedMsg_.content] as [MailContent, ...MailContent[]] }
+              : {}
+          }
+          yield* InfraLogger.logDebug("Sending email").pipe(Effect.annotateLogs("msg", inspect(renderedMsg, false, 5)))
 
-        const ret = yield* Effect
-          .callback<
-            [sgMail.ClientResponse, Record<string, unknown>],
-            Error | sgMail.ResponseError
-          >(
-            (resume) =>
-              void sgMail.send(
-                renderedMsg as any, // sue me
-                msg.isMultiple ?? true,
-                (err, result) =>
-                  err
-                    ? resume(Effect.fail(err))
-                    : resume(Effect.sync(() => result))
-              )
-          )
-          .pipe(Effect.mapError((raw) => new SendMailError({ raw })))
+          const ret = yield* Effect
+            .callback<
+              [sgMail.ClientResponse, Record<string, unknown>],
+              Error | sgMail.ResponseError
+            >(
+              (resume) =>
+                void sgMail.send(
+                  renderedMsg as any, // sue me
+                  msg.isMultiple ?? true,
+                  (err, result) =>
+                    err
+                      ? resume(Effect.fail(err))
+                      : resume(Effect.sync(() => result))
+                )
+            )
+            .pipe(Effect.mapError((raw) => new SendMailError({ raw })))
 
-        // const event = {
-        //   name: "EmailSent",
-        //   properties: {
-        //     templateId: msg.templateId
-        //   }
-        // }
-        // yield* InfraLogger.logDebug("Tracking email event").annotateLogs("event", event.$$.pretty)
-        // const { trackEvent } = yield* AiContextService
-        // trackEvent(event)
-        return ret
-      })
+          // const event = {
+          //   name: "EmailSent",
+          //   properties: {
+          //     templateId: msg.templateId
+          //   }
+          // }
+          // yield* InfraLogger.logDebug("Tracking email event").annotateLogs("event", event.$$.pretty)
+          // const { trackEvent } = yield* AiContextService
+          // trackEvent(event)
+          return ret
+        }
+      )
     })
   })
 
@@ -68,23 +90,24 @@ export function Sendgrid(config: SendgridConfig) {
 /**
  * @hidden
  */
-export function renderMessage(forceFake: boolean) {
+export function renderMessage(forceFake: boolean, fakeMailAddress: string) {
   let i = 0
   const makeId = () => i++
+  const makeFakeEmail = () => fakeMailAddress.replace("{i}", String(makeId()))
   return forceFake
     ? (msg: EmailMsg) =>
       dropUndefinedT({
         ...msg,
-        to: msg.to && renderFake(msg.to, makeId),
-        cc: msg.cc && renderFake(msg.cc, makeId),
-        bcc: msg.bcc && renderFake(msg.bcc, makeId)
+        to: msg.to && renderFake(msg.to, makeFakeEmail),
+        cc: msg.cc && renderFake(msg.cc, makeFakeEmail),
+        bcc: msg.bcc && renderFake(msg.bcc, makeFakeEmail)
       })
     : (msg: EmailMsg) =>
       dropUndefinedT({
         ...msg,
-        to: msg.to && renderFakeIfTest(msg.to, makeId),
-        cc: msg.cc && renderFakeIfTest(msg.cc, makeId),
-        bcc: msg.bcc && renderFakeIfTest(msg.bcc, makeId)
+        to: msg.to && renderFakeIfTest(msg.to, makeFakeEmail),
+        cc: msg.cc && renderFakeIfTest(msg.cc, makeFakeEmail),
+        bcc: msg.bcc && renderFakeIfTest(msg.bcc, makeFakeEmail)
       })
 }
 
@@ -100,10 +123,10 @@ export function isTestAddress(to: EmailData) {
   )
 }
 
-function renderFake(addr: EmailData | readonly EmailData[], makeId: () => number) {
+function renderFake(addr: EmailData | readonly EmailData[], makeEmail: () => string) {
   return {
     name: renderMailData(addr),
-    email: `test+${makeId()}@nomizz.com`
+    email: makeEmail()
   }
 }
 const eq = Equivalence.mapInput(
@@ -117,14 +140,14 @@ function isEmailDataArray(md: EmailData | readonly EmailData[]): md is readonly
 
 // TODO: should just not add any already added email address
 // https://stackoverflow.com/a/53603076/11595834
-function renderFakeIfTest(addr: EmailData | readonly EmailData[], makeId: () => number) {
+function renderFakeIfTest(addr: EmailData | readonly EmailData[], makeEmail: () => string) {
   if (isEmailDataArray(addr)) {
     return Array.dedupeWith(
-      addr.map((x) => (isTestAddress(x) ? renderFake(x, makeId) : x)),
+      addr.map((x) => (isTestAddress(x) ? renderFake(x, makeEmail) : x)),
       eq
     )
   }
-  return isTestAddress(addr) ? renderFake(addr, makeId) : addr
+  return isTestAddress(addr) ? renderFake(addr, makeEmail) : addr
 }
 
 function renderMailData(md: EmailData | readonly EmailData[]): string {

package/src/Emailer/fake.ts

@@ -1,13 +1,13 @@
-import { Effect } from "effect-app"
+import * as Effect from "effect-app/Effect"
+import { Emailer } from "effect-app/Emailer"
 import { pretty } from "effect-app/utils"
 import { InfraLogger } from "../logger.js"
-import { Emailer } from "./service.js"
 
 const makeFake = InfraLogger
   .logInfo("FAKE Emailer Service enabled")
   .pipe(Effect.map(() =>
     Emailer.of({
-      sendMail: Effect.fn("Fake.sendMail")((msg) =>
+      sendMail: Effect.fn("Emailer.sendMail", { attributes: { "messaging.system": "fake" } })((msg) =>
         InfraLogger
           .logDebug(`Fake send mail`)
           .pipe(Effect.annotateLogs("msg", pretty(msg)))

package/src/MainFiberSet.ts

@@ -1,14 +1,17 @@
-import { Effect, Fiber, FiberSet, Layer, ServiceMap } from "effect-app"
-import type {} from "effect/Scope"
+import * as Context from "effect-app/Context"
+import * as Effect from "effect-app/Effect"
+import * as Layer from "effect-app/Layer"
+import * as Fiber from "effect/Fiber"
+import * as FiberSet from "effect/FiberSet"
+
 import { InfraLogger } from "./logger.js"
 import { reportNonInterruptedFailureCause } from "./QueueMaker/errors.js"
 import { setRootParentSpan } from "./RequestFiberSet.js"
 
 const make = Effect.gen(function*() {
   const set = yield* FiberSet.make<unknown, never>()
-  const add = (...fibers: Fiber.Fiber<never, never>[]) =>
-    Effect.sync(() => fibers.forEach((_) => FiberSet.addUnsafe(set, _)))
-  const addAll = (fibers: readonly Fiber.Fiber<never, never>[]) =>
+  const add = (...fibers: Fiber.Fiber<never>[]) => Effect.sync(() => fibers.forEach((_) => FiberSet.addUnsafe(set, _)))
+  const addAll = (fibers: readonly Fiber.Fiber<never>[]) =>
     Effect.sync(() => fibers.forEach((_) => FiberSet.addUnsafe(set, _)))
   const join = FiberSet.size(set).pipe(
     Effect.andThen((count) => InfraLogger.logDebug(`Joining ${count} current fibers on the MainFiberSet`)),
@@ -62,15 +65,14 @@ const make = Effect.gen(function*() {
  * you should register these long running fibers in a FiberSet, and join them at the end of your main program.
  * This way any errors will blow up the main program instead of fibers dying unknowingly.
  */
-export class MainFiberSet extends ServiceMap.Service<MainFiberSet>()("MainFiberSet", { make }) {
+export class MainFiberSet extends Context.Service<MainFiberSet>()("MainFiberSet", { make }) {
   static readonly Live = Layer.effect(this, this.make)
-  static readonly JoinLive = this.asEffect().pipe(
+  static readonly JoinLive = this.pipe(
     Effect.andThen((_) => _.join),
     Layer.effectDiscard,
     Layer.provide(this.Live)
   )
-  static readonly run = <A, R>(self: Effect.Effect<A, never, R>) =>
-    this.asEffect().pipe(Effect.andThen((_) => _.run(self)))
+  static readonly run = <A, R>(self: Effect.Effect<A, never, R>) => this.pipe(Effect.andThen((_) => _.run(self)))
   static readonly forkDaemonReport = <A, E, R>(self: Effect.Effect<A, E, R>) =>
-    this.asEffect().pipe(Effect.andThen((_) => _.forkDaemonReport(self)))
+    this.pipe(Effect.andThen((_) => _.forkDaemonReport(self)))
 }