@effect-app/infra 4.0.0-beta.7 → 4.0.0-beta.71

package/src/QueueMaker/memQueue.ts

@@ -1,12 +1,11 @@
 import { Cause, Tracer } from "effect"
-import { Effect, Fiber, flow, S } from "effect-app"
-import * as Q from "effect/Queue"
+import { Effect, Fiber, flow, type NonEmptyReadonlyArray, S } from "effect-app"
 import { pretty } from "effect-app/utils"
+import * as Q from "effect/Queue"
 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<
@@ -26,8 +25,12 @@ export function makeMemQueue<
     const qDrain = yield* mem.getOrCreateQueue(queueDrainName)
 
     const wireSchema = S.Struct({ body: schema, meta: QueueMeta })
+    const wireSchemaJson = S.fromJsonString(S.toCodecJson(wireSchema))
+    const encodePublish = S.encodeEffect(wireSchemaJson)
     const drainW = S.Struct({ body: drainSchema, meta: QueueMeta })
-    const parseDrain = flow(S.decodeUnknownEffect(drainW), Effect.orDie)
+    const drainWJson = S.fromJsonString(S.toCodecJson(drainW))
+
+    const parseDrain = flow(S.decodeUnknownEffect(drainWJson), Effect.orDie)
 
     const queue = {
       publish: (...messages: NonEmptyReadonlyArray<Evt>) =>
@@ -37,10 +40,8 @@ export function makeMemQueue<
               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(
+                  encodePublish({ 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 })
@@ -58,42 +59,40 @@ export function makeMemQueue<
         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.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
-                            }
+          parseDrain(msg).pipe(
+            Effect.orDie,
+            Effect
+              .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
                           }
-                        )
-                    )
-                  if (meta.span) {
-                    effect = Effect.withParentSpan(effect, Tracer.externalSpan(meta.span))
-                  }
-                  return effect
-                })
-            )
-        return Q.take(qDrain)
+                        }
+                      )
+                  )
+                if (meta.span) {
+                  effect = Effect.withParentSpan(effect, Tracer.externalSpan(meta.span))
+                }
+                return effect
+              })
+          )
+        return Q
+          .take(qDrain)
           .pipe(
             Effect
               .flatMap((x) =>

package/src/QueueMaker/sbqueue.ts

@@ -1,12 +1,11 @@
 import { Tracer } from "effect"
-import { Cause, Effect, flow, S } from "effect-app"
+import { Cause, Effect, flow, type NonEmptyReadonlyArray, S } from "effect-app"
 import type { StringId } from "effect-app/Schema"
 import { pretty } from "effect-app/utils"
 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<
@@ -22,8 +21,11 @@ export function makeServiceBusQueue<
     body: schema,
     meta: QueueMeta
   })
+  const wireSchemaJson = S.fromJsonString(S.toCodecJson(wireSchema))
+  const encodePublish = S.encodeEffect(wireSchemaJson)
   const drainW = S.Struct({ body: drainSchema, meta: QueueMeta })
-  const parseDrain = flow(S.decodeUnknownEffect(drainW), Effect.orDie)
+  const drainWJson = S.fromJsonString(S.toCodecJson(drainW))
+  const parseDrain = flow(S.decodeUnknownEffect(drainWJson), Effect.orDie)
 
   return Effect.gen(function*() {
     const sender = yield* Sender
@@ -40,55 +42,51 @@ export function makeServiceBusQueue<
         handleEvent: (ks: DrainEvt) => Effect.Effect<void, DrainE, DrainR>,
         sessionId?: string
       ) => {
-        // 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
-                            }
+        function processMessage(messageBody: unknown) {
+          return parseDrain(messageBody).pipe(
+            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
                           }
-                        )
-                    )
-                  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((_) => _)
-            )
+                        }
+                      )
+                  )
+                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 receiver
@@ -111,17 +109,22 @@ export function makeServiceBusQueue<
         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
+                .forEach(messages, (m) =>
+                  encodePublish({
+                    body: m,
+                    meta: requestContext
+                  })
+                    .pipe(
+                      Effect.orDie,
+                      Effect.map((body) => ({
+                        body,
+                        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",

package/src/RequestContext.ts

@@ -1,11 +1,11 @@
-import { S, ServiceMap } from "effect-app"
+import { Context, S } 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 ServiceMap.Reference("Locale", { defaultValue: (): Locale => "en" }) {}
+export class LocaleRef extends Context.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 = ServiceMap.Tag<RequestContext>()
+  // static Tag = Context.Tag<RequestContext>()
 
   static toMonitoring(this: void, self: RequestContext) {
     return {

package/src/RequestFiberSet.ts

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Effect, Fiber, FiberSet, Layer, ServiceMap, type Tracer } from "effect-app"
+import { Context, Effect, Fiber, FiberSet, Layer, Option, type Tracer } from "effect-app"
 import { reportRequestError, reportUnknownRequestError } from "./api/reportError.js"
 import { InfraLogger } from "./logger.js"
 
@@ -8,8 +8,8 @@ const getRootParentSpan = Effect.gen(function*() {
     Effect.catchTag("NoSuchElementError", () => Effect.succeed(null))
   )
   if (!span) return span
-  while (span._tag === "Span" && span.parent !== undefined) {
-    span = span.parent
+  while (span._tag === "Span" && Option.isSome(span.parent)) {
+    span = span.parent.value
   }
   return span
 })
@@ -92,7 +92,7 @@ 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 ServiceMap.Service<RequestFiberSet>()("RequestFiberSet", { make }) {
+export class RequestFiberSet extends Context.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)))

package/src/Store/ContextMapContainer.ts

@@ -1,4 +1,4 @@
-import { Data, Effect, Layer, ServiceMap } from "effect-app"
+import { Context, Data, Effect, Layer } from "effect-app"
 import { ContextMap } from "./service.js"
 
 // TODO: we have to create a new contextmap on every request.
@@ -7,7 +7,7 @@ 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 ServiceMap.Reference("ContextMapContainer", {
+export class ContextMapContainer extends Context.Reference("ContextMapContainer", {
   defaultValue: (): ContextMap | "root" => "root"
 }) {
   static readonly layer = Layer.effect(this, ContextMap.make.pipe(Effect.map(ContextMap.of)))

package/src/Store/Cosmos.ts

@@ -328,15 +328,13 @@ function makeCosmosStore({ prefix }: StorageConfig) {
                             .query<M>(q, { partitionKey: mainPartitionKey })
                             .fetchAll()
                             .then(({ resources }) =>
-                              resources.map((_) =>
-                                ({
-                                  ...pipe(
-                                    defaultValues,
-                                    Struct.pick(f.select!.filter((_) => typeof _ === "string"))
-                                  ),
-                                  ...mapReverseId(_ as any)
-                                }) as any
-                              )
+                              resources.map((_) => ({
+                                ...pipe(
+                                  defaultValues,
+                                  Struct.pick(f.select!.filter((_) => typeof _ === "string") as never[])
+                                ),
+                                ...mapReverseId(_ as any)
+                              }))
                             )
                           : container
                             .items
@@ -404,7 +402,9 @@ function makeCosmosStore({ prefix }: StorageConfig) {
                   Effect
                     .flatMap((x) => {
                       if (x.statusCode === 412 || x.statusCode === 404 || x.statusCode === 409) {
-                        return Effect.fail(new OptimisticConcurrencyException({ type: name, id: e[idKey], code: x.statusCode }))
+                        return Effect.fail(
+                          new OptimisticConcurrencyException({ type: name, id: e[idKey], code: x.statusCode })
+                        )
                       }
                       if (x.statusCode > 299 || x.statusCode < 200) {
                         return Effect.die(

package/src/Store/Disk.ts

@@ -66,11 +66,10 @@ function makeDiskStoreInt<IdKey extends keyof Encoded, Encoded extends FieldValu
     }
 
     // lock file for cross-process coordination during initialization
-    const lockFile = file + ".lock"
 
     // wrap initialization in file lock to prevent race conditions in multi-worker setups
     const store = yield* fu.withFileLock(
-      lockFile,
+      file,
       Effect.gen(function*() {
         const shouldSeed = !(fs.existsSync(file))
 
@@ -143,7 +142,7 @@ export function makeDiskStore({ prefix }: StorageConfig, dir: string) {
           const storesSem = Semaphore.makeUnsafe(1)
           const primary = yield* makeDiskStoreInt(prefix, idKey, "primary", dir, name, seed, config?.defaultValues)
           const stores = new Map<string, Store<IdKey, Encoded>>([["primary", primary]])
-          const ctx = yield* Effect.services<R>()
+          const ctx = yield* Effect.context<R>()
           const getStore = !config?.allowNamespace
             ? Effect.succeed(primary)
             : storeId.asEffect().pipe(Effect.flatMap((namespace) => {

package/src/Store/Memory.ts

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
-import { Array, Effect, flow, type NonEmptyReadonlyArray, Option, Order, pipe, Ref, Result, Semaphore, ServiceMap, Struct } from "effect-app"
+import { Array, Context, Effect, flow, type NonEmptyReadonlyArray, Option, Order, pipe, Ref, Result, Semaphore, Struct } from "effect-app"
 import { NonEmptyString255 } from "effect-app/Schema"
 import { get } from "effect-app/utils"
 import { InfraLogger } from "../logger.js"
@@ -24,7 +24,7 @@ export function memFilter<T extends FieldValues, U extends keyof T = never>(f: F
         )
         const n = Struct.pick(i, keys)
         subKeys.forEach((subKey) => {
-          n[subKey.key] = i[subKey.key]!.map(Struct.pick(subKey.subKeys))
+          n[subKey.key] = i[subKey.key]!.map(Struct.pick(subKey.subKeys as never[]))
         })
         return n as M
       }) as any
@@ -72,9 +72,7 @@ export function memFilter<T extends FieldValues, U extends keyof T = never>(f: F
 }
 
 const defaultNs: NonEmptyString255 = NonEmptyString255("primary")
-export class storeId
-  extends ServiceMap.Reference("StoreId", { defaultValue: (): NonEmptyString255 => defaultNs })
-{}
+export class storeId extends Context.Reference("StoreId", { defaultValue: (): NonEmptyString255 => defaultNs }) {}
 
 function logQuery(f: FilterArgs<any, any>, defaultValues?: any) {
   return InfraLogger
@@ -267,7 +265,7 @@ export const makeMemoryStore = () => ({
         seed,
         config?.defaultValues
       )
-      const ctx = yield* Effect.services<R>()
+      const ctx = yield* Effect.context<R>()
       const stores = new Map([["primary", primary]])
       const getStore = !config?.allowNamespace
         ? Effect.succeed(primary)

package/src/Store/service.ts

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import type { UniqueKey } from "@azure/cosmos"
-import { Effect, type NonEmptyReadonlyArray, type Option, type Redacted, ServiceMap } from "effect-app"
+import { Context, Effect, type NonEmptyReadonlyArray, type Option, type Redacted } from "effect-app"
 import type { OptimisticConcurrencyException } from "../errors.js"
 import type { FilterResult } from "../Model/filter/filterApi.js"
 import type { FieldValues } from "../Model/filter/types.js"
@@ -89,7 +89,7 @@ export interface Store<
   queryRaw: <Out>(query: RawQuery<Encoded, Out>) => Effect.Effect<readonly Out[]>
 }
 
-export class StoreMaker extends ServiceMap.Opaque<StoreMaker, {
+export class StoreMaker extends Context.Opaque<StoreMaker, {
   make: <IdKey extends keyof Encoded, Encoded extends FieldValues, R = never, E = never>(
     name: string,
     idKey: IdKey,
@@ -170,7 +170,7 @@ export const makeContextMap = () => {
 
 const makeMap = Effect.sync(() => makeContextMap())
 
-export class ContextMap extends ServiceMap.Opaque<ContextMap>()("effect-app/ContextMap", { make: makeMap }) {
+export class ContextMap extends Context.Opaque<ContextMap>()("effect-app/ContextMap", { make: makeMap }) {
 }
 
 export type PersistenceModelType<Encoded extends object> = Encoded & {