@effect-app/infra 0.198.2 → 0.199.2

package/src/services/RequestContextContainer.ts

@@ -1,5 +1,9 @@
+import { NonEmptyString255 } from "@effect-app/schema"
+import { Context, Effect, FiberRef, Layer, Option } from "effect-app"
 import { RequestId } from "effect-app/ids"
+import { TagClassId } from "effect-app/service"
 import { RequestContext } from "../RequestContext.js"
+import { restoreFromRequestContext } from "./Store/Memory.js"
 
 /**
  * @tsplus type RequestContextContainer
@@ -11,33 +15,41 @@ export class RequestContextContainer extends TagClassId("effect-app/RequestConte
   start: (f: RequestContext) => Effect<void>
 }>() {
   static get get(): Effect<RequestContext, never, RequestContextContainer> {
-    return RequestContextContainer.flatMap((_) => _.requestContext)
+    return Effect.flatMap(RequestContextContainer, (_) => _.requestContext)
   }
   static get getOption() {
-    return Effect
-      .contextWith((_: Context<never>) => Context.getOption(_, RequestContextContainer))
-      .flatMap((requestContext) =>
-        requestContext.isSome()
-          ? requestContext.value.requestContext.map(Option.some)
+    return Effect.flatMap(
+      Effect
+        .contextWith((_: Context<never>) => Context.getOption(_, RequestContextContainer)),
+      (requestContext) =>
+        Option.isSome(requestContext)
+          ? Effect.map(requestContext.value.requestContext, Option.some)
           : Effect.sync(() => Option.none())
-      )
+    )
   }
   static readonly live = Effect
-    .sync(() => new RequestContext({ name: NonEmptyString255("_root_"), rootId: RequestId("_root_"), locale: "en" }))
-    .andThen(FiberRef.make<RequestContext>)
-    .map((ref) =>
-      new RequestContextContainer({
-        requestContext: ref.get,
-        update: (f: (a: RequestContext) => RequestContext) =>
-          ref.getAndUpdate(f).tap((rc) => Effect.annotateCurrentSpan(rc.spanAttributes)),
-        start: (a: RequestContext) => ref.set(a).andThen(a.restoreStoreId)
-      })
+    .andThen(
+      Effect
+        .sync(() =>
+          new RequestContext({ name: NonEmptyString255("_root_"), rootId: RequestId("_root_"), locale: "en" })
+        ),
+      FiberRef.make<RequestContext>
+    )
+    .pipe(
+      Effect.map((ref) =>
+        new RequestContextContainer({
+          requestContext: FiberRef.get(ref),
+          update: (f: (a: RequestContext) => RequestContext) =>
+            Effect.tap(FiberRef.getAndUpdate(ref, f), (rc) => Effect.annotateCurrentSpan(spanAttributes(rc))),
+          start: (a: RequestContext) => Effect.zipRight(FiberRef.set(ref, a), restoreFromRequestContext(a))
+        })
+      ),
+      Layer.scoped(this)
     )
-    .toLayerScoped(this)
 }
 
 /** @tsplus static RequestContext.Ops Tag */
-export const RCTag = GenericTag<RequestContext>("@services/RCTag")
+export const RCTag = Context.GenericTag<RequestContext>("@services/RCTag")
 
 /**
  * @tsplus getter RequestContext spanAttributes

package/src/services/Store/ContextMapContainer.ts

@@ -1,3 +1,5 @@
+import { Context, Effect, FiberRef, Layer, Option } from "effect-app"
+import { TagClassId } from "effect-app/service"
 import { ContextMap } from "./service.js"
 
 // TODO: we have to create a new contextmap on every request.
@@ -14,24 +16,35 @@ export class ContextMapContainer extends TagClassId("effect-app/ContextMapContai
   start: Effect<void>
 }>() {
   static get get(): Effect<ContextMap, never, ContextMapContainer> {
-    return ContextMapContainer.flatMap((_) => _.get)
+    return Effect.flatMap(ContextMapContainer, (_) => _.get)
   }
   static get getOption() {
-    return Effect
-      .contextWith((_: Context<never>) => Context.getOption(_, ContextMapContainer))
-      .flatMap((ctx) =>
-        ctx.isSome()
-          ? ctx.value.get.map(Option.some)
+    return Effect.flatMap(
+      Effect
+        .contextWith((_: Context<never>) => Context.getOption(_, ContextMapContainer)),
+      (ctx) =>
+        Option.isSome(ctx)
+          ? Effect.map(ctx.value.get, Option.some)
           : Effect.sync(() => Option.none())
-      )
+    )
   }
 
-  static readonly live = ContextMap
-    .make
-    .flatMap(FiberRef.make<ContextMap>)
-    .map((ref) => new ContextMapContainer({ get: ref.get, start: ContextMap.make.flatMap((_) => ref.set(_)) }))
-    .toLayerScoped(this)
+  static readonly live = Effect
+    .flatMap(
+      ContextMap.make,
+      FiberRef.make<ContextMap>
+    )
+    .pipe(
+      Effect
+        .map((ref) =>
+          new ContextMapContainer({
+            get: FiberRef.get(ref),
+            start: Effect.flatMap(ContextMap.make, (_) => FiberRef.set(ref, _))
+          })
+        ),
+      Layer.scoped(this)
+    )
 }
 
 /** @tsplus static ContextMap.Ops Tag */
-export const RCTag = GenericTag<ContextMap>("@services/RCTag")
+export const RCTag = Context.GenericTag<ContextMap>("@services/RCTag")

package/src/services/Store/Cosmos/query.ts

@@ -1,3 +1,5 @@
+import { Effect, Equivalence, pipe, ReadonlyArray } from "effect-app"
+import type { NonEmptyReadonlyArray } from "effect-app"
 import { assertUnreachable } from "effect-app/utils"
 import type { FilterR, FilterResult } from "../filterApi/query.js"
 import type { FilterJoinSelect, JoinFindFilter, LegacyFilter, StoreWhereFilter, SupportedValues } from "../service.js"
@@ -123,12 +125,14 @@ export function buildWhereCosmosQuery(
     SELECT f
     FROM ${name} f
     ${
-      filter
-        .where
-        .filter((_) => _.key.includes(".-1."))
-        .map((_) => _.key.split(".-1.")[0])
-        .map((_) => `JOIN ${_} IN f.${_}`)
-        .dedupeWith(Equivalence.string)
+      pipe(
+        filter
+          .where
+          .filter((_) => _.key.includes(".-1."))
+          .map((_) => _.key.split(".-1.")[0])
+          .map((_) => `JOIN ${_} IN f.${_}`),
+        ReadonlyArray.dedupeWith(Equivalence.string)
+      )
         .join("\n")
     }
     WHERE f.id != @id AND ${
@@ -368,11 +372,13 @@ export function buildWhereCosmosQuery3(
     FROM ${name} f
 
     ${
-      values
-        .filter((_) => _.path.includes(".-1."))
-        .map((_) => _.path.split(".-1.")[0])
-        .map((_) => `JOIN ${_} IN f.${_}`)
-        .dedupeWith(Equivalence.string)
+      pipe(
+        values
+          .filter((_) => _.path.includes(".-1."))
+          .map((_) => _.path.split(".-1.")[0])
+          .map((_) => `JOIN ${_} IN f.${_}`),
+        ReadonlyArray.dedupeWith(Equivalence.string)
+      )
         .join("\n")
     }