@effect-app/infra 3.10.0 → 4.0.0-beta.0

package/src/QueueMaker/memQueue.ts

@@ -1,10 +1,12 @@
 import { Cause, Tracer } from "effect"
 import { Effect, Fiber, flow, S } from "effect-app"
+import * as Q from "effect/Queue"
 import { pretty } from "effect-app/utils"
 import { MemQueue } from "../adapters/memQueue.js"
 import { getRequestContext, setupRequestContextWithCustomSpan } from "../api/setupRequest.js"
 import { InfraLogger } from "../logger.js"
 import { reportNonInterruptedFailure, reportNonInterruptedFailureCause } from "./errors.js"
+import type { NonEmptyReadonlyArray } from "effect-app"
 import { type QueueBase, QueueMeta } from "./service.js"
 
 export function makeMemQueue<
@@ -15,8 +17,8 @@ export function makeMemQueue<
 >(
   queueName: string,
   queueDrainName: string,
-  schema: S.Schema<Evt, EvtE>,
-  drainSchema: S.Schema<DrainEvt, DrainEvtE>
+  schema: S.Codec<Evt, EvtE>,
+  drainSchema: S.Codec<DrainEvt, DrainEvtE>
 ) {
   return Effect.gen(function*() {
     const mem = yield* MemQueue
@@ -25,108 +27,105 @@ export function makeMemQueue<
 
     const wireSchema = S.Struct({ body: schema, meta: QueueMeta })
     const drainW = S.Struct({ body: drainSchema, meta: QueueMeta })
-    const parseDrain = flow(S.decodeUnknown(drainW), Effect.orDie)
+    const parseDrain = flow(S.decodeUnknownEffect(drainW), Effect.orDie)
 
-    return {
-      publish: (...messages) =>
-        Effect
-          .gen(function*() {
-            const requestContext = yield* getRequestContext
-            return yield* Effect
-              .forEach(messages, (m) =>
-                // we JSON encode, because that is what the wire also does, and it reveals holes in e.g unknown encoders (Date->String)
-                S.encode(wireSchema)({ body: m, meta: requestContext }).pipe(
-                  Effect.orDie,
-                  Effect
-                    .andThen(JSON.stringify),
-                  // .tap((msg) => info("Publishing Mem Message: " + utils.inspect(msg)))
-                  Effect.flatMap((_) => q.offer(_))
-                ), { discard: true })
-          })
+    const queue = {
+      publish: (...messages: NonEmptyReadonlyArray<Evt>) =>
+        getRequestContext
           .pipe(
+            Effect.flatMap((requestContext) =>
+              Effect
+                .forEach(messages, (m) =>
+                  // we JSON encode, because that is what the wire also does, and it reveals holes in e.g unknown encoders (Date->String)
+                  S.encodeEffect(wireSchema)({ body: m, meta: requestContext }).pipe(
+                    Effect.orDie,
+                    Effect
+                      .map(JSON.stringify),
+                    // .tap((msg) => info("Publishing Mem Message: " + utils.inspect(msg)))
+                    Effect.flatMap((_) => Q.offer(q, _))
+                  ), { discard: true })
+            ),
             Effect.withSpan("queue.publish: " + queueName, {
-              captureStackTrace: false,
               kind: "producer",
               attributes: { "message_tags": messages.map((_) => _._tag) }
-            })
+            }, { captureStackTrace: false })
           ),
       drain: <DrainE, DrainR>(
         handleEvent: (ks: DrainEvt) => Effect.Effect<void, DrainE, DrainR>,
         sessionId?: string
-      ) =>
-        Effect.gen(function*() {
-          const silenceAndReportError = reportNonInterruptedFailure({ name: "MemQueue.drain." + queueDrainName })
-          const reportError = reportNonInterruptedFailureCause({ name: "MemQueue.drain." + queueDrainName })
-          const processMessage = (msg: string) =>
-            // we JSON parse, because that is what the wire also does, and it reveals holes in e.g unknown encoders (Date->String)
-            Effect
-              .sync(() => JSON.parse(msg))
-              .pipe(
-                Effect.flatMap(parseDrain),
-                Effect.orDie,
-                Effect
-                  .flatMap(({ body, meta }) => {
-                    let effect = InfraLogger
-                      .logDebug(`[${queueDrainName}] Processing incoming message`)
-                      .pipe(
-                        Effect.annotateLogs({ body: pretty(body), meta: pretty(meta) }),
-                        Effect.zipRight(handleEvent(body)),
-                        silenceAndReportError,
-                        (_) =>
-                          setupRequestContextWithCustomSpan(
-                            _,
-                            meta,
-                            `queue.drain: ${queueDrainName}.${body._tag}`,
-                            {
-                              captureStackTrace: false,
-                              kind: "consumer",
-                              attributes: {
-                                "queue.name": queueDrainName,
-                                "queue.sessionId": sessionId,
-                                "queue.input": body
-                              }
-                            }
-                          )
-                      )
-                    if (meta.span) {
-                      effect = Effect.withParentSpan(effect, Tracer.externalSpan(meta.span))
-                    }
-                    return effect
-                  })
-              )
-          return yield* qDrain
-            .take
+      ) => {
+        const silenceAndReportError = reportNonInterruptedFailure({ name: "MemQueue.drain." + queueDrainName })
+        const reportError = reportNonInterruptedFailureCause({ name: "MemQueue.drain." + queueDrainName })
+        const processMessage = (msg: string) =>
+          // we JSON parse, because that is what the wire also does, and it reveals holes in e.g unknown encoders (Date->String)
+          Effect
+            .sync(() => JSON.parse(msg))
             .pipe(
+              Effect.flatMap(parseDrain),
+              Effect.orDie,
               Effect
-                .flatMap((x) =>
-                  processMessage(x).pipe(
-                    Effect.uninterruptible,
-                    Effect.fork,
-                    Effect.flatMap(Fiber.join),
-                    // normally a failed item would be returned to the queue and retried up to X times.
-                    Effect.flatMap((_) =>
-                      _._tag === "Failure" && !Cause.isInterruptedOnly(_.cause)
-                        ? qDrain.offer(x).pipe(
-                          // TODO: retry count tracking and max retries.
-                          Effect.delay("5 seconds"),
-                          Effect.tapErrorCause(reportError),
-                          Effect.forkDaemon
+                .flatMap(({ body, meta }) => {
+                  let effect = InfraLogger
+                    .logDebug(`[${queueDrainName}] Processing incoming message`)
+                    .pipe(
+                      Effect.annotateLogs({ body: pretty(body), meta: pretty(meta) }),
+                      Effect.andThen(handleEvent(body)),
+                      silenceAndReportError,
+                      (_) =>
+                        setupRequestContextWithCustomSpan(
+                          _,
+                          meta,
+                          `queue.drain: ${queueDrainName}.${body._tag}`,
+                          {
+                            captureStackTrace: false,
+                            kind: "consumer",
+                            attributes: {
+                              "queue.name": queueDrainName,
+                              "queue.sessionId": sessionId,
+                              "queue.input": body
+                            }
+                          }
                         )
-                        : Effect.void
                     )
-                  )
-                ),
-              silenceAndReportError,
-              Effect.withSpan(`queue.drain: ${queueDrainName}`, {
-                attributes: {
-                  "queue.type": "mem",
-                  "queue.name": queueDrainName,
-                  "queue.sessionId": sessionId
-                }
-              }),
-              Effect.forever
+                  if (meta.span) {
+                    effect = Effect.withParentSpan(effect, Tracer.externalSpan(meta.span))
+                  }
+                  return effect
+                })
             )
-        })
-    } satisfies QueueBase<Evt, DrainEvt>
+        return Q.take(qDrain)
+          .pipe(
+            Effect
+              .flatMap((x) =>
+                processMessage(x).pipe(
+                  Effect.uninterruptible,
+                  Effect.forkChild,
+                  Effect.flatMap(Fiber.join),
+                  // normally a failed item would be returned to the queue and retried up to X times.
+                  Effect.flatMap((_) =>
+                    _._tag === "Failure" && !Cause.hasInterruptsOnly(_.cause)
+                      ? Q.offer(qDrain, x).pipe(
+                        // TODO: retry count tracking and max retries.
+                        Effect.delay("5 seconds"),
+                        Effect.tapCause(reportError),
+                        Effect.forkDetach
+                      )
+                      : Effect.void
+                  )
+                )
+              ),
+            silenceAndReportError,
+            Effect.withSpan(`queue.drain: ${queueDrainName}`, {
+              attributes: {
+                "queue.type": "mem",
+                "queue.name": queueDrainName,
+                "queue.sessionId": sessionId
+              }
+            }),
+            Effect.forever
+          )
+      }
+    }
+    return queue as QueueBase<Evt, DrainEvt>
   })
 }

package/src/QueueMaker/sbqueue.ts

@@ -6,6 +6,7 @@ import { Receiver, Sender } from "../adapters/ServiceBus.js"
 import { getRequestContext, setupRequestContextWithCustomSpan } from "../api/setupRequest.js"
 import { InfraLogger } from "../logger.js"
 import { reportNonInterruptedFailure, reportNonInterruptedFailureCause, reportQueueError } from "./errors.js"
+import type { NonEmptyReadonlyArray } from "effect-app"
 import { type QueueBase, QueueMeta } from "./service.js"
 
 export function makeServiceBusQueue<
@@ -14,15 +15,15 @@ export function makeServiceBusQueue<
   EvtE,
   DrainEvtE
 >(
-  schema: S.Schema<Evt, EvtE>,
-  drainSchema: S.Schema<DrainEvt, DrainEvtE>
+  schema: S.Codec<Evt, EvtE>,
+  drainSchema: S.Codec<DrainEvt, DrainEvtE>
 ) {
   const wireSchema = S.Struct({
     body: schema,
     meta: QueueMeta
   })
   const drainW = S.Struct({ body: drainSchema, meta: QueueMeta })
-  const parseDrain = flow(S.decodeUnknown(drainW), Effect.orDie)
+  const parseDrain = flow(S.decodeUnknownEffect(drainW), Effect.orDie)
 
   return Effect.gen(function*() {
     const sender = yield* Sender
@@ -34,103 +35,100 @@ export function makeServiceBusQueue<
     // This will make sure that the host receives the error (MainFiberSet.join), who will then interrupt everything and commence a shutdown and restart of app
     // const deferred = yield* Deferred.make<never, ServiceBusError | Error>()
 
-    return {
+    const queue = {
       drain: <DrainE, DrainR>(
         handleEvent: (ks: DrainEvt) => Effect.Effect<void, DrainE, DrainR>,
         sessionId?: string
-      ) =>
-        Effect
-          .gen(function*() {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            function processMessage(messageBody: any) {
-              return Effect
-                .sync(() => JSON.parse(messageBody))
-                .pipe(
-                  Effect.flatMap((x) => parseDrain(x)),
-                  Effect.orDie,
-                  Effect
-                    .flatMap(({ body, meta }) => {
-                      let effect = InfraLogger
-                        .logDebug(`[${receiver.name}] Processing incoming message`)
-                        .pipe(
-                          Effect.annotateLogs({
-                            body: pretty(body),
-                            meta: pretty(meta)
-                          }),
-                          Effect.zipRight(handleEvent(body)),
-                          Effect.orDie
+      ) => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        function processMessage(messageBody: any) {
+          return Effect
+            .sync(() => JSON.parse(messageBody))
+            .pipe(
+              Effect.flatMap((x) => parseDrain(x)),
+              Effect.orDie,
+              Effect
+                .flatMap(({ body, meta }) => {
+                  let effect = InfraLogger
+                    .logDebug(`[${receiver.name}] Processing incoming message`)
+                    .pipe(
+                      Effect.annotateLogs({
+                        body: pretty(body),
+                        meta: pretty(meta)
+                      }),
+                      Effect.andThen(handleEvent(body)),
+                      Effect.orDie
+                    )
+                    // we silenceAndReportError here, so that the error is reported, and moves into the Exit.
+                    .pipe(
+                      silenceAndReportError,
+                      (_) =>
+                        setupRequestContextWithCustomSpan(
+                          _,
+                          meta,
+                          `queue.drain: ${receiver.name}${sessionId ? `#${sessionId}` : ""}.${body._tag}`,
+                          {
+                            captureStackTrace: false,
+                            kind: "consumer",
+                            attributes: {
+                              "queue.name": receiver.name,
+                              "queue.sessionId": sessionId,
+                              "queue.input": body
+                            }
+                          }
                         )
-                        // we silenceAndReportError here, so that the error is reported, and moves into the Exit.
-                        .pipe(
-                          silenceAndReportError,
-                          (_) =>
-                            setupRequestContextWithCustomSpan(
-                              _,
-                              meta,
-                              `queue.drain: ${receiver.name}${sessionId ? `#${sessionId}` : ""}.${body._tag}`,
-                              {
-                                captureStackTrace: false,
-                                kind: "consumer",
-                                attributes: {
-                                  "queue.name": receiver.name,
-                                  "queue.sessionId": sessionId,
-                                  "queue.input": body
-                                }
-                              }
-                            )
-                        )
-                      if (meta.span) {
-                        effect = Effect.withParentSpan(effect, Tracer.externalSpan(meta.span))
-                      }
-                      return effect
-                    }),
-                  Effect
-                    // we reportError here, so that we report the error only, and keep flowing
-                    .tapErrorCause(reportError),
-                  // we still need to flatten the Exit.
-                  Effect.flatMap((_) => _)
-                )
-            }
+                    )
+                  if (meta.span) {
+                    effect = Effect.withParentSpan(effect, Tracer.externalSpan(meta.span))
+                  }
+                  return effect
+                }),
+              Effect
+                // we reportError here, so that we report the error only, and keep flowing
+                .tapCause(reportError),
+              // we still need to flatten the Exit.
+              Effect.flatMap((_) => _)
+            )
+        }
 
-            return yield* receiver
-              .subscribe({
-                processMessage: (x) => processMessage(x.body).pipe(Effect.uninterruptible),
-                processError: (err) => reportQueueError(Cause.fail(err.error))
-                // Deferred.completeWith(
-                //   deferred,
-                //   reportFatalQueueError(Cause.fail(err.error))
-                //     .pipe(Effect.andThen(Effect.fail(err.error)))
-                // )
-              }, sessionId)
-          })
+        return receiver
+          .subscribe({
+            processMessage: (x) => processMessage(x.body).pipe(Effect.uninterruptible),
+            processError: (err) => reportQueueError(Cause.fail(err.error))
+            // Deferred.completeWith(
+            //   deferred,
+            //   reportFatalQueueError(Cause.fail(err.error))
+            //     .pipe(Effect.andThen(Effect.fail(err.error)))
+            // )
+          }, sessionId)
           // .pipe(Effect.andThen(Deferred.await(deferred).pipe(Effect.orDie))),
           .pipe(
             Effect.andThen(Effect.never)
-          ),
+          )
+      },
 
-      publish: (...messages) =>
-        Effect
-          .gen(function*() {
-            const requestContext = yield* getRequestContext
-            return yield* sender.sendMessages(
-              messages.map((m) => ({
-                body: JSON.stringify(
-                  S.encodeSync(wireSchema)({
-                    body: m,
-                    meta: requestContext
-                  })
-                ),
-                messageId: m.id, /* correllationid: requestId */
-                contentType: "application/json",
-                sessionId: "sessionId" in m ? m.sessionId as string : undefined as unknown as string // TODO: optional
-              }))
-            )
-          })
-          .pipe(Effect.withSpan("queue.publish: " + sender.name, {
-            captureStackTrace: false,
-            kind: "producer",
-            attributes: { "message_tags": messages.map((_) => _._tag) }
-          }))
-    } satisfies QueueBase<Evt, DrainEvt>
+      publish: (...messages: NonEmptyReadonlyArray<Evt>) =>
+        getRequestContext
+          .pipe(
+            Effect.flatMap((requestContext) =>
+              Effect.forEach(messages, (m) =>
+                S.encodeEffect(wireSchema)({
+                  body: m,
+                  meta: requestContext
+                }).pipe(Effect.orDie, Effect.map((encoded) => ({
+                  body: JSON.stringify(encoded),
+                  messageId: m.id, /* correllationid: requestId */
+                  contentType: "application/json",
+                  sessionId: "sessionId" in m ? m.sessionId as string : undefined as unknown as string // TODO: optional
+                }))))
+              .pipe(Effect.flatMap((msgs) => sender.sendMessages(msgs)))
+            ),
+            Effect.withSpan("queue.publish: " + sender.name, {
+              kind: "producer",
+              attributes: { "message_tags": messages.map((_) => _._tag) }
+            }, { captureStackTrace: false })
+          )
+    }
+    return queue as QueueBase<Evt, DrainEvt>
   })
 }

package/src/RequestContext.ts

@@ -1,11 +1,11 @@
-import { Context, S } from "effect-app"
+import { S, ServiceMap } from "effect-app"
 import { UserProfileId } from "effect-app/ids"
 import { NonEmptyString255 } from "effect-app/Schema"
 
 export const Locale = S.Literal("en", "de")
 export type Locale = typeof Locale.Type
 
-export class LocaleRef extends Context.Reference<LocaleRef>()("Locale", { defaultValue: (): Locale => "en" }) {}
+export class LocaleRef extends ServiceMap.Reference("Locale", { defaultValue: (): Locale => "en" }) {}
 
 export class RequestContext extends S.ExtendedClass<
   RequestContext,
@@ -23,7 +23,7 @@ export class RequestContext extends S.ExtendedClass<
   /** @deprecated */
   userProfile: S.optional(S.Struct({ sub: UserProfileId })) //
 }) {
-  // static Tag = Context.Tag<RequestContext>()
+  // static Tag = ServiceMap.Tag<RequestContext>()
 
   static toMonitoring(this: void, self: RequestContext) {
     return {

package/src/RequestFiberSet.ts

@@ -1,15 +1,15 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Context, Effect, Fiber, FiberSet, Option, type Tracer } from "effect-app"
+import { Effect, Fiber, FiberSet, Layer, ServiceMap, type Tracer } from "effect-app"
 import { reportRequestError, reportUnknownRequestError } from "./api/reportError.js"
 import { InfraLogger } from "./logger.js"
 
 const getRootParentSpan = Effect.gen(function*() {
   let span: Tracer.AnySpan | null = yield* Effect.currentSpan.pipe(
-    Effect.catchTag("NoSuchElementException", () => Effect.succeed(null))
+    Effect.catchTag("NoSuchElementError", () => Effect.succeed(null))
   )
   if (!span) return span
-  while (span._tag === "Span" && Option.isSome(span.parent)) {
-    span = span.parent.value
+  while (span._tag === "Span" && span.parent !== undefined) {
+    span = span.parent
   }
   return span
 })
@@ -19,17 +19,17 @@ export const setRootParentSpan = <A, E, R>(self: Effect.Effect<A, E, R>) =>
 
 const make = Effect.gen(function*() {
   const set = yield* FiberSet.make<any, any>()
-  const add = (...fibers: Fiber.RuntimeFiber<any, any>[]) =>
-    Effect.sync(() => fibers.forEach((_) => FiberSet.unsafeAdd(set, _)))
-  const addAll = (fibers: readonly Fiber.RuntimeFiber<any, any>[]) =>
-    Effect.sync(() => fibers.forEach((_) => FiberSet.unsafeAdd(set, _)))
+  const add = (...fibers: Fiber.Fiber<any, any>[]) =>
+    Effect.sync(() => fibers.forEach((_) => FiberSet.addUnsafe(set, _)))
+  const addAll = (fibers: readonly Fiber.Fiber<any, any>[]) =>
+    Effect.sync(() => fibers.forEach((_) => FiberSet.addUnsafe(set, _)))
   const join = FiberSet.size(set).pipe(
     Effect.andThen((count) => InfraLogger.logInfo(`Joining ${count} current fibers on the RequestFiberSet`)),
     Effect.andThen(FiberSet.join(set))
   )
   const run = FiberSet.run(set)
   const register = <A, E, R>(self: Effect.Effect<A, E, R>) =>
-    self.pipe(Effect.fork, Effect.tap(add), Effect.andThen(Fiber.join))
+    self.pipe(Effect.forkChild, Effect.tap(add), Effect.andThen(Fiber.join))
 
   // const waitUntilEmpty = Effect.gen(function*() {
   //   const currentSize = yield* FiberSet.size(set)
@@ -92,12 +92,14 @@ const make = Effect.gen(function*() {
  * Whenever you fork a fiber for a Request, and you want to prevent dependent services to close prematurely on interruption,
  * like the ServiceBus Sender, you should register these fibers in this FiberSet.
  */
-export class RequestFiberSet extends Context.TagMakeId("RequestFiberSet", make)<RequestFiberSet>() {
-  static readonly Live = this.toLayerScoped()
-  static readonly register = <A, E, R>(self: Effect.Effect<A, E, R>) => this.use((_) => _.register(self))
-  static readonly run = <A, E, R>(self: Effect.Effect<A, E, R>) => this.use((_) => _.run(self))
+export class RequestFiberSet extends ServiceMap.Service<RequestFiberSet>()("RequestFiberSet", { make }) {
+  static readonly Live = Layer.effect(this, this.make)
+  static readonly register = <A, E, R>(self: Effect.Effect<A, E, R>) =>
+    this.asEffect().pipe(Effect.andThen((_) => _.register(self)))
+  static readonly run = <A, E, R>(self: Effect.Effect<A, E, R>) =>
+    this.asEffect().pipe(Effect.andThen((_) => _.run(self)))
   static readonly forkDaemonReport = <R, E, A>(self: Effect.Effect<A, E, R>) =>
-    this.use((_) => _.forkDaemonReport(self))
+    this.asEffect().pipe(Effect.andThen((_) => _.forkDaemonReport(self)))
   static readonly forkDaemonReportUnexpected = <R, E, A>(self: Effect.Effect<A, E, R>) =>
-    this.use((_) => _.forkDaemonReportUnexpected(self))
+    this.asEffect().pipe(Effect.andThen((_) => _.forkDaemonReportUnexpected(self)))
 }

package/src/Store/ContextMapContainer.ts

@@ -1,4 +1,4 @@
-import { Context, Data, Effect, Layer } from "effect-app"
+import { Data, Effect, Layer, ServiceMap } from "effect-app"
 import { ContextMap } from "./service.js"
 
 // TODO: we have to create a new contextmap on every request.
@@ -7,14 +7,14 @@ import { ContextMap } from "./service.js"
 // we can call another start after startup. but it would be even better if we could Die on accessing rootmap
 // we could also make the ContextMap optional, and when missing, issue a warning instead?
 
-export class ContextMapContainer extends Context.Reference<ContextMapContainer>()("ContextMapContainer", {
+export class ContextMapContainer extends ServiceMap.Reference("ContextMapContainer", {
   defaultValue: (): ContextMap | "root" => "root"
 }) {
-  static readonly layer = Layer.effect(this, ContextMap.make)
+  static readonly layer = Layer.effect(this, ContextMap.make.pipe(Effect.map(ContextMap.of)))
 }
 
 export class ContextMapNotStartedError extends Data.TaggedError("ContextMapNotStartedError") {}
 
-export const getContextMap = ContextMapContainer.pipe(
+export const getContextMap = ContextMapContainer.asEffect().pipe(
   Effect.filterOrFail((_) => _ !== "root", () => new ContextMapNotStartedError())
 )