@effect-app/infra 0.207.0 → 0.208.1

package/src/services/QueueMaker/sbqueue.ts

@@ -17,7 +17,7 @@ import { NonEmptyString255, struct } from "effect-app/schema"
 import { pretty } from "effect-app/utils"
 import { setupRequestContext } from "../../api/setupRequest.js"
 import { RequestContextContainer } from "../RequestContextContainer.js"
-import { forkDaemonReportQueue, reportNonInterruptedFailure, reportNonInterruptedFailureCause } from "./errors.js"
+import { reportNonInterruptedFailure, reportNonInterruptedFailureCause } from "./errors.js"
 import { type QueueBase, QueueMeta } from "./service.js"
 
 /**
@@ -53,85 +53,87 @@ export function makeServiceBusQueue<
       makeDrain: <DrainE, DrainR>(
         handleEvent: (ks: DrainEvt) => Effect<void, DrainE, DrainR>
       ) =>
-        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 }) =>
-                    Effect
-                      .logDebug(`$$ [${queueDrainName}] Processing incoming message`)
-                      .pipe(
-                        Effect.annotateLogs({
-                          body: pretty(body),
-                          meta: pretty(meta)
-                        }),
-                        Effect
-                          .zipRight(handleEvent(body)),
-                        Effect
-                          .orDie
-                      )
-                      // we silenceAndReportError here, so that the error is reported, and moves into the Exit.
-                      .pipe(
-                        silenceAndReportError,
-                        (_) =>
-                          setupRequestContext(
-                            _,
-                            RequestContext.inherit(meta.requestContext, {
-                              id: RequestId(body.id),
-                              locale: "en" as const,
-                              name: NonEmptyString255(body._tag)
+        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 }) =>
+                      Effect
+                        .logDebug(`$$ [${queueDrainName}] Processing incoming message`)
+                        .pipe(
+                          Effect.annotateLogs({
+                            body: pretty(body),
+                            meta: pretty(meta)
+                          }),
+                          Effect
+                            .zipRight(handleEvent(body)),
+                          Effect
+                            .orDie
+                        )
+                        // we silenceAndReportError here, so that the error is reported, and moves into the Exit.
+                        .pipe(
+                          silenceAndReportError,
+                          (_) =>
+                            setupRequestContext(
+                              _,
+                              RequestContext.inherit(meta.requestContext, {
+                                id: RequestId(body.id),
+                                locale: "en" as const,
+                                name: NonEmptyString255(body._tag)
+                              })
+                            ),
+                          Effect
+                            .withSpan("queue.drain", {
+                              attributes: { "queue.name": queueDrainName },
+                              parent: meta.span
+                                ? Tracer.externalSpan(meta.span)
+                                : undefined
                             })
-                          ),
-                        Effect
-                          .withSpan("queue.drain", {
-                            attributes: { "queue.name": queueDrainName },
-                            parent: meta.span
-                              ? Tracer.externalSpan(meta.span)
-                              : undefined
-                          })
-                      )
-                  ),
-                Effect
-                  // we reportError here, so that we report the error only, and keep flowing
-                  .tapErrorCause(reportError)
-              )
-          }
+                        )
+                    ),
+                  Effect
+                    // we reportError here, so that we report the error only, and keep flowing
+                    .tapErrorCause(reportError)
+                )
+            }
 
-          return yield* $(
-            subscribe({
-              processMessage: (x) => processMessage(x.body).pipe(Effect.uninterruptible),
-              processError: (err) => Effect.sync(() => captureException(err.error))
-            })
-              .pipe(Effect.provide(receiverLayer))
-          )
-        }),
+            return yield* $(
+              subscribe({
+                processMessage: (x) => processMessage(x.body).pipe(Effect.uninterruptible),
+                processError: (err) => Effect.sync(() => captureException(err.error))
+              })
+                .pipe(Effect.provide(receiverLayer))
+            )
+          })
+          .pipe(Effect.andThen(Effect.never)),
 
       publish: (...messages) =>
-        Effect.gen(function*($) {
-          const requestContext = yield* $(rcc.requestContext)
-          const currentSpan = yield* $(Effect.currentSpan.pipe(Effect.orDie))
-          const span = Tracer.externalSpan(currentSpan)
-          return yield* $(
-            Effect
-              .promise(() =>
-                s.sendMessages(
-                  messages.map((m) => ({
-                    body: JSON.stringify(
-                      S.encodeSync(wireSchema)({ body: m, meta: { requestContext, span } })
-                    ),
-                    messageId: m.id, /* correllationid: requestId */
-                    contentType: "application/json"
-                  }))
+        Effect
+          .gen(function*($) {
+            const requestContext = yield* $(rcc.requestContext)
+            const currentSpan = yield* $(Effect.currentSpan.pipe(Effect.orDie))
+            const span = Tracer.externalSpan(currentSpan)
+            return yield* $(
+              Effect
+                .promise(() =>
+                  s.sendMessages(
+                    messages.map((m) => ({
+                      body: JSON.stringify(
+                        S.encodeSync(wireSchema)({ body: m, meta: { requestContext, span } })
+                      ),
+                      messageId: m.id, /* correllationid: requestId */
+                      contentType: "application/json"
+                    }))
+                  )
                 )
-              )
-              .pipe(forkDaemonReportQueue)
-          )
-        })
+            )
+          })
     } satisfies QueueBase<Evt, DrainEvt>
   })
 }

package/src/services/QueueMaker/service.ts

@@ -1,5 +1,6 @@
 import { struct } from "@effect-app/schema"
-import { type Effect, type NonEmptyReadonlyArray, S, type Scope } from "effect-app"
+import { S } from "effect-app"
+import type { Effect, NonEmptyReadonlyArray, Scope } from "effect-app"
 import { RequestContext } from "../../RequestContext.js"
 import type { RequestContextContainer } from "../RequestContextContainer.js"
 import type { ContextMapContainer } from "../Store/ContextMapContainer.js"
@@ -7,7 +8,7 @@ import type { ContextMapContainer } from "../Store/ContextMapContainer.js"
 export interface QueueBase<Evt, DrainEvt> {
   makeDrain: <DrainE, DrainR>(
     makeHandleEvent: (ks: DrainEvt) => Effect<void, DrainE, DrainR>
-  ) => Effect<void, never, Scope | RequestContextContainer | ContextMapContainer | DrainR>
+  ) => Effect<never, never, Scope | RequestContextContainer | ContextMapContainer | DrainR>
   publish: (
     ...messages: NonEmptyReadonlyArray<Evt>
   ) => Effect<void>

package/src/services/RepositoryBase.ts

@@ -87,8 +87,7 @@ export abstract class RepositoryBaseC<
     parseMany: (a: readonly PM[]) => Effect<readonly T[]>
     parseMany2: <A, R>(
       a: readonly PM[],
-      schema: S.Schema<A, Omit<PM, "_etag">, R>,
-      batch?: boolean | "inherit" | undefined
+      schema: S.Schema<A, Omit<PM, "_etag">, R>
     ) => Effect<readonly A[], S.ParseResult.ParseError, R>
     all: Effect<PM[]>
     filter: FilterFunc<PM>
@@ -566,7 +565,10 @@ export function makeRepo<
                 Unify
                   .unify(
                     a.schema
-                      ? r.utils.parseMany2(_, a.schema as any, a.batch)
+                      ? r.utils.parseMany2(
+                        _,
+                        a.schema as any
+                      )
                       : r.utils.parseMany(_)
                   )
             )
@@ -604,11 +606,22 @@ export function makeRepo<
                   .flatMap(cms, (cm) =>
                     decodeMany(items.map((_) => mapReverse(_, cm.set)))
                       .pipe(Effect.orDie, Effect.withSpan("parseMany"))),
-              parseMany2: (items, schema, batch) =>
+              parseMany2: (items, schema) =>
                 Effect
                   .flatMap(cms, (cm) =>
                     S
-                      .decode(S.array(schema).pipe(S.batching(batch)))(
+                      .decode(
+                        S.array(schema).pipe(S.batching(
+                          S
+                            .AST
+                            .getBatchingAnnotation(schema.ast)
+                            .pipe(Option.getOrUndefined)
+                            ?.valueOf() as
+                              | boolean
+                              | "inherit" // somehow otherwise inefers as string ?
+                              | undefined
+                        ))
+                      )(
                         items.map((_) => mapReverse(_, cm.set) as unknown as Omit<PM, "_etag">)
                       )
                       .pipe(Effect.orDie, Effect.withSpan("parseMany2"))),

package/src/services/query/dsl.ts

@@ -134,7 +134,6 @@ export class Project<A, TFieldValues extends FieldValues, R, TType extends "one"
     current: Query<TFieldValues> | QueryWhere<TFieldValues> | QueryEnd<TFieldValues, TType>
     schema: S.Schema<A, TFieldValues, R>
     mode: "raw" | "transform"
-    batch?: boolean | "inherit" | undefined
   }>
   implements QueryProjection<TFieldValues, A, R>
 {
@@ -210,20 +209,11 @@ export const project: {
     R = never,
     TType extends "one" | "many" = "many"
   >(
-    schema: S.Schema<A, TFieldValues, R>,
-    batch?: boolean | "inherit" | undefined
+    schema: S.Schema<A, TFieldValues, R>
   ): (
     current: Query<TFieldValues> | QueryWhere<TFieldValues> | QueryEnd<TFieldValues, TType>
   ) => QueryProjection<TFieldValues, A, R, TType>
-} = (schema: any, batchOrMode) => (current: any) =>
-  new Project(
-    {
-      current,
-      schema,
-      mode: batchOrMode === "raw" ? batchOrMode : "transform",
-      batch: batchOrMode !== "raw" ? batchOrMode : undefined
-    } as any
-  )
+} = (schema: any, mode = "transform") => (current: any) => new Project({ current, /* TODO: why */ schema, mode } as any)
 
 export type FilterWheres = {
   <

package/src/services/query/new-kid-interpreter.ts

@@ -16,7 +16,6 @@ type Result<TFieldValues extends FieldValues, A = TFieldValues, R = never> = {
   order: { key: FieldPath<TFieldValues>; direction: "ASC" | "DESC" }[]
   ttype: "one" | "many" | "count" | undefined
   mode: "raw" | "transform" | undefined
-  batch: boolean | "inherit" | undefined
 }
 
 const interpret = <TFieldValues extends FieldValues, A = TFieldValues, R = never>(_: QAll<TFieldValues, A, R>) => {
@@ -29,8 +28,7 @@ const interpret = <TFieldValues extends FieldValues, A = TFieldValues, R = never
     skip: undefined,
     order: [],
     ttype: undefined,
-    mode: undefined,
-    batch: undefined
+    mode: undefined
   }
 
   const upd = (
@@ -43,7 +41,6 @@ const interpret = <TFieldValues extends FieldValues, A = TFieldValues, R = never
     if (v.ttype !== undefined) data.ttype = v.ttype
     if (v.schema !== undefined) data.schema = v.schema
     if (v.mode !== undefined) data.mode = v.mode
-    if (v.batch !== undefined) data.batch = v.batch
   }
 
   pipe(
@@ -120,7 +117,6 @@ const interpret = <TFieldValues extends FieldValues, A = TFieldValues, R = never
         upd(interpret(v.current))
         data.schema = v.schema
         data.mode = v.mode
-        data.batch = v.batch
       }
     })
   )
@@ -155,7 +151,6 @@ export const toFilter = <
     schema,
     order: Option.getOrUndefined(toNonEmptyArray(a.order)),
     ttype: a.ttype,
-    batch: a.batch,
     mode: a.mode ?? "transform",
     filter: a.filter.length
       ? {