@effect-app/infra 4.0.0-beta.19 → 4.0.0-beta.190

package/src/api/routing.ts

@@ -2,22 +2,30 @@
 /* eslint-disable @typescript-eslint/no-unsafe-argument */
 /* eslint-disable @typescript-eslint/no-empty-object-type */
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Config, Effect, Layer, type NonEmptyReadonlyArray, Predicate, S, type Scope } from "effect-app"
+import { Config, Effect, Layer, type NonEmptyReadonlyArray, Predicate, Ref, S, type Scope, Stream } from "effect-app"
+import { getMeta } from "effect-app/client"
 import { type HttpHeaders } from "effect-app/http"
+import { Invalidation } from "effect-app/rpc"
 import { type GetEffectContext, type GetEffectError, type RpcContextMap } from "effect-app/rpc/RpcContextMap"
 import { type TypeTestId } from "effect-app/TypeTest"
 import { typedKeysOf, typedValuesOf } from "effect-app/utils"
 import { type Yieldable } from "effect/Effect"
 import { Rpc, RpcGroup, type RpcSerialization, RpcServer } from "effect/unstable/rpc"
 import { type LayerUtils } from "./layerUtils.js"
-import { type RouterMiddleware } from "./routing/middleware.js"
+import { RequestType as RequestTypeAnnotation, type RouterMiddleware } from "./routing/middleware.js"
 
 export * from "./routing/middleware.js"
 
+export const applyRequestTypeInterruptibility = <A, E, R>(
+  requestType: "command" | "query",
+  effect: Effect.Effect<A, E, R>
+) => requestType === "command" ? Rpc.uninterruptible(effect) : effect
+
 // it's the result of extending S.Req setting success, config
 // it's a schema plus some metadata
 export type AnyRequestModule = S.Top & {
   _tag: string // unique identifier for the request module
+  type: "command" | "query" | "stream"
   config: any // ?
   success: S.Top // validates the success response
   error: S.Top // validates the failure response
@@ -65,7 +73,10 @@ interface HandlerBase<Action extends AnyRequestModule, RT extends RequestType, A
   new(): {}
   _tag: RT
   stack: string
-  handler: (req: S.Schema.Type<Action>, headers: HttpHeaders.Headers) => Effect.Effect<A, E, R>
+  handler: (
+    req: S.Schema.Type<Action>,
+    headers: HttpHeaders.Headers
+  ) => Effect.Effect<A, E, R> | Stream.Stream<A, E, R>
 }
 
 export interface Handler<Action extends AnyRequestModule, RT extends RequestType, R> extends
@@ -126,6 +137,28 @@ type Match<
       Scope.Scope
     >
   >
+
+  <A extends GetSuccessShape<Resource[Key], RT>, R2 = never, E = never>(
+    f: Stream.Stream<A, E, R2>
+  ): Handler<
+    Resource[Key],
+    RT,
+    Exclude<
+      Exclude<R2, GetEffectContext<RequestContextMap, Resource[Key]["config"]>>,
+      Scope.Scope
+    >
+  >
+
+  <A extends GetSuccessShape<Resource[Key], RT>, R2 = never, E = never>(
+    f: (req: S.Schema.Type<Resource[Key]>) => Stream.Stream<A, E, R2>
+  ): Handler<
+    Resource[Key],
+    RT,
+    Exclude<
+      Exclude<R2, GetEffectContext<RequestContextMap, Resource[Key]["config"]>>,
+      Scope.Scope
+    >
+  >
 }
 
 export type RouteMatcher<
@@ -182,10 +215,9 @@ export const makeRouter = <
    * if `check` is provided, the router will only be created if the effect succeeds with true
    */
   function matchFor<
-    const ModuleName extends string,
     const Resource extends Record<string, any>
   >(
-    rsc: Resource & { meta: { moduleName: ModuleName } },
+    rsc: Resource,
     options?: { check?: Effect.Effect<boolean> }
   ) {
     type HandlerWithInputGen<
@@ -230,10 +262,32 @@ export const makeRouter = <
       GetEffectContext<RequestContextMap, Action["config"]> | ContextProviderA
     >
 
+    type HandlerWithInputStream<
+      Action extends AnyRequestModule,
+      RT extends RequestType
+    > = (
+      req: S.Schema.Type<Action>
+    ) => Stream.Stream<
+      GetSuccessShape<Action, RT>,
+      S.Schema.Type<GetFailure<Action>> | S.SchemaError,
+      GetEffectContext<RequestContextMap, Action["config"]> | ContextProviderA
+    >
+
+    type HandlerStream<
+      Action extends AnyRequestModule,
+      RT extends RequestType
+    > = Stream.Stream<
+      GetSuccessShape<Action, RT>,
+      S.Schema.Type<GetFailure<Action>> | S.SchemaError,
+      GetEffectContext<RequestContextMap, Action["config"]> | ContextProviderA
+    >
+
     type Handlers<Action extends AnyRequestModule, RT extends RequestType> =
       | HandlerWithInputGen<Action, RT>
       | HandlerWithInputEff<Action, RT>
       | HandlerEff<Action, RT>
+      | HandlerWithInputStream<Action, RT>
+      | HandlerStream<Action, RT>
 
     type HandlersDecoded<Action extends AnyRequestModule> = Handlers<Action, RequestTypes.DECODED>
 
@@ -241,15 +295,17 @@ export const makeRouter = <
       | { raw: HandlerWithInputGen<Action, RequestTypes.RAW> }
       | { raw: HandlerWithInputEff<Action, RequestTypes.RAW> }
       | { raw: HandlerEff<Action, RequestTypes.RAW> }
+      | { raw: HandlerWithInputStream<Action, RequestTypes.RAW> }
+      | { raw: HandlerStream<Action, RequestTypes.RAW> }
 
     type AnyHandlers<Action extends AnyRequestModule> = HandlersRaw<Action> | HandlersDecoded<Action>
 
-    const { meta } = rsc
+    const meta = getMeta(rsc)
 
     type RequestModules = FilterRequestModules<Resource>
     const requestModules = typedKeysOf(rsc).reduce((acc, cur) => {
       if (Predicate.isObjectKeyword(rsc[cur]) && rsc[cur]["success"]) {
-        acc[cur as keyof RequestModules] = rsc[cur] as RequestModules[keyof RequestModules]
+        acc[cur as keyof RequestModules] = rsc[cur]
       }
       return acc
     }, {} as RequestModules)
@@ -260,13 +316,16 @@ export const makeRouter = <
           // handlerImpl is the actual handler implementation
           if (handlerImpl[Symbol.toStringTag] === "GeneratorFunction") handlerImpl = Effect.fnUntraced(handlerImpl)
           const stack = new Error().stack?.split("\n").slice(2).join("\n")
-          return Effect.isEffect(handlerImpl)
+          const isValueShape = Effect.isEffect(handlerImpl) || Stream.isStream(handlerImpl)
+          return isValueShape
+            // oxlint-disable-next-line typescript/no-extraneous-class
             ? class {
               static request = rsc[cur]
               static stack = stack
               static _tag = RequestTypes.DECODED
               static handler = () => handlerImpl
             }
+            // oxlint-disable-next-line typescript/no-extraneous-class
             : class {
               static request = rsc[cur]
               static stack = stack
@@ -283,13 +342,16 @@ export const makeRouter = <
             (handlerImpl: any) => {
               if (handlerImpl[Symbol.toStringTag] === "GeneratorFunction") handlerImpl = Effect.fnUntraced(handlerImpl)
               const stack = new Error().stack?.split("\n").slice(2).join("\n")
-              return Effect.isEffect(handlerImpl)
+              const isValueShape = Effect.isEffect(handlerImpl) || Stream.isStream(handlerImpl)
+              return isValueShape
+                // oxlint-disable-next-line typescript/no-extraneous-class
                 ? class {
                   static request = rsc[cur]
                   static stack = stack
                   static _tag = RequestTypes.RAW
                   static handler = () => handlerImpl
                 }
+                // oxlint-disable-next-line typescript/no-extraneous-class
                 : class {
                   static request = rsc[cur]
                   static stack = stack
@@ -319,6 +381,8 @@ export const makeRouter = <
             Impl[K] extends { raw: any }
               ? Impl[K]["raw"] extends (...args: any[]) => Effect.Effect<any, any, infer R> ? R
               : Impl[K]["raw"] extends Effect.Effect<any, any, infer R> ? R
+              : Impl[K]["raw"] extends (...args: any[]) => Stream.Stream<any, any, infer R> ? R
+              : Impl[K]["raw"] extends Stream.Stream<any, any, infer R> ? R
               : Impl[K]["raw"] extends (...args: any[]) => Generator<
                 Yieldable<any, any, any, infer R>,
                 any,
@@ -327,6 +391,8 @@ export const makeRouter = <
               : never
               : Impl[K] extends (...args: any[]) => Effect.Effect<any, any, infer R> ? R
               : Impl[K] extends Effect.Effect<any, any, infer R> ? R
+              : Impl[K] extends (...args: any[]) => Stream.Stream<any, any, infer R> ? R
+              : Impl[K] extends Stream.Stream<any, any, infer R> ? R
               : Impl[K] extends (...args: any[]) => Generator<
                 Yieldable<any, any, any, infer R>,
                 any,
@@ -386,12 +452,68 @@ export const makeRouter = <
                   static success = S.toEncoded(resource.success)
                 } as any
                 : resource,
-              (payload: any, headers: any) =>
-                (handler.handler(payload, headers) as Effect.Effect<unknown, unknown, unknown>).pipe(
+              (payload: any, headers: any) => {
+                const result = handler.handler(payload, headers)
+                if (Stream.isStream(result)) {
+                  // Wrap stream items as { _tag: "value", value } and append a final
+                  // { _tag: "done", metadata } chunk carrying accumulated invalidation keys.
+                  // V2: on failure, convert to { _tag: "error", error, metadata } chunk so
+                  // clients can invalidate queries even when the stream fails.
+                  const keysRef = Ref.makeUnsafe<ReadonlyArray<Invalidation.InvalidationKey>>([])
+                  const invalidationSet = Invalidation.makeInvalidationSet(keysRef)
+                  return Stream.concat(
+                    (result as Stream.Stream<any, any, any>).pipe(
+                      Stream.map((item: any) => ({ _tag: "value" as const, value: item })),
+                      Stream.provideService(Invalidation.InvalidationSet, invalidationSet),
+                      // V3: after each value chunk, drain accumulated keys and emit a "metadata"
+                      // chunk if any keys were collected since the last drain. This lets clients
+                      // invalidate queries mid-stream without waiting for the "done" chunk.
+                      Stream.flatMap((valueChunk: any) =>
+                        Stream
+                          .fromEffect(
+                            Ref.getAndSet(keysRef, []).pipe(
+                              Effect.map((keys) =>
+                                keys.length > 0
+                                  ? [
+                                    valueChunk,
+                                    { _tag: "metadata" as const, metadata: { invalidateQueries: keys } }
+                                  ]
+                                  : [valueChunk]
+                              )
+                            )
+                          )
+                          .pipe(Stream.flatMap(Stream.fromIterable))
+                      ),
+                      // V2: catch stream failures and embed them in the stream as an error chunk
+                      Stream.catch((err: any) =>
+                        Stream.fromEffect(
+                          Ref.get(keysRef).pipe(
+                            Effect.flatMap((keys) =>
+                              Effect.fail({
+                                _tag: "error" as const,
+                                error: err,
+                                metadata: { invalidateQueries: keys }
+                              })
+                            )
+                          )
+                        )
+                      )
+                    ),
+                    Stream.fromEffect(
+                      Ref.get(keysRef).pipe(
+                        Effect.map((keys) => ({ _tag: "done" as const, metadata: { invalidateQueries: keys } }))
+                      )
+                    )
+                  )
+                }
+                const effect = (result as Effect.Effect<unknown, unknown, unknown>).pipe(
                   Effect.withSpan(`Request.${meta.moduleName}.${resource._tag}`, {}, {
                     captureStackTrace: () => handler.stack // capturing the handler stack is the main reason why we are doing the span here
                   })
                 )
+
+                return applyRequestTypeInterruptibility(resource.type, effect)
+              }
             ] as const
             return acc
           }, {} as any) as {
@@ -415,9 +537,28 @@ export const makeRouter = <
           const rpcs = RpcGroup
             .make(
               ...typedValuesOf(mapped).map(([resource]) => {
-                return Rpc
-                  .make(resource._tag, { payload: resource, success: resource.success, error: resource.error })
+                const isStream = resource.type === "stream"
+                const isCommand = resource.type === "command"
+                return (isCommand
+                  ? Invalidation.makeCommandRpc(resource._tag, {
+                    payload: resource,
+                    success: resource.success,
+                    error: resource.error
+                  })
+                  : isStream
+                  ? Invalidation.makeStreamRpc(resource._tag, {
+                    payload: resource,
+                    success: resource.success,
+                    error: resource.error,
+                    stream: true as const
+                  })
+                  : Rpc.make(resource._tag, {
+                    payload: resource,
+                    success: resource.success,
+                    error: resource.error
+                  }))
                   .annotate(middleware.requestContext, resource.config ?? {})
+                  .annotate(RequestTypeAnnotation, resource.type)
               })
             )
             .prefix(`${meta.moduleName}.`)

package/src/api/setupRequest.ts

@@ -1,9 +1,18 @@
-import { Effect, Layer, Tracer } from "effect-app"
+import { Effect, Layer, Option, Tracer } from "effect-app"
 import { NonEmptyString255 } from "effect-app/Schema"
+import { SqlClient } from "effect/unstable/sql"
 import { LocaleRef, RequestContext, spanAttributes } from "../RequestContext.js"
 import { ContextMapContainer } from "../Store/ContextMapContainer.js"
 import { storeId } from "../Store/Memory.js"
 
+const withSqlTransaction = <R, E, A>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
+  Effect.serviceOption(SqlClient.SqlClient).pipe(
+    Effect.flatMap(Option.match({
+      onNone: () => self,
+      onSome: (sql) => sql.withTransaction(self).pipe(Effect.orDie)
+    }))
+  )
+
 export const getRequestContext = Effect
   .all({
     span: Effect.currentSpan.pipe(Effect.orDie),
@@ -12,7 +21,7 @@ export const getRequestContext = Effect
   })
   .pipe(
     Effect.map(({ locale, namespace, span }) =>
-      new RequestContext({
+      RequestContext.make({
         span: Tracer.externalSpan(span),
         locale,
         namespace,
@@ -43,16 +52,25 @@ const withRequestSpan = (name = "request", options?: Tracer.SpanOptions) => <R,
       )
   )
 
+export interface SetupRequestOptions {
+  readonly withTransaction?: boolean
+}
+
 export const setupRequestContextFromCurrent =
-  (name = "request", options?: Tracer.SpanOptions) => <R, E, A>(self: Effect.Effect<A, E, R>) =>
+  (name = "request", options?: Tracer.SpanOptions & SetupRequestOptions) => <R, E, A>(self: Effect.Effect<A, E, R>) =>
     self
       .pipe(
+        options?.withTransaction === true ? withSqlTransaction : (_) => _,
         withRequestSpan(name, options),
-        Effect.provide(ContextMapContainer.layer)
+        Effect.provide(ContextMapContainer.layer, { local: true })
       )
 
 // TODO: consider integrating Effect.withParentSpan
-export function setupRequestContext<R, E, A>(self: Effect.Effect<A, E, R>, requestContext: RequestContext) {
+export function setupRequestContext<R, E, A>(
+  self: Effect.Effect<A, E, R>,
+  requestContext: RequestContext,
+  options?: SetupRequestOptions
+) {
   const layer = Layer.mergeAll(
     ContextMapContainer.layer,
     Layer.succeed(LocaleRef, requestContext.locale),
@@ -60,8 +78,9 @@ export function setupRequestContext<R, E, A>(self: Effect.Effect<A, E, R>, reque
   )
   return self
     .pipe(
+      options?.withTransaction === true ? withSqlTransaction : (_) => _,
       withRequestSpan(requestContext.name),
-      Effect.provide(layer)
+      Effect.provide(layer, { local: true })
     )
 }
 
@@ -69,7 +88,7 @@ export function setupRequestContextWithCustomSpan<R, E, A>(
   self: Effect.Effect<A, E, R>,
   requestContext: RequestContext,
   name: string,
-  options?: Tracer.SpanOptions
+  options?: Tracer.SpanOptions & SetupRequestOptions
 ) {
   const layer = Layer.mergeAll(
     ContextMapContainer.layer,
@@ -78,7 +97,8 @@ export function setupRequestContextWithCustomSpan<R, E, A>(
   )
   return self
     .pipe(
+      options?.withTransaction === true ? withSqlTransaction : (_) => _,
       withRequestSpan(name, options),
-      Effect.provide(layer)
+      Effect.provide(layer, { local: true })
     )
 }

package/src/arbs.ts

@@ -5,9 +5,11 @@ import { type S } from "effect-app"
 import { setFaker } from "effect-app/faker"
 import * as FastCheck from "effect/testing/FastCheck"
 import { Random } from "fast-check"
-import * as rand from "pure-rand"
+import { congruential32 } from "pure-rand/generator/congruential32"
 
-const rnd = new Random(rand.congruential32(5))
+const seed = 5
+const rng = congruential32(seed)
+const rnd = new Random(rng)
 
 setFaker(faker)
 

package/src/errorReporter.ts

@@ -13,47 +13,41 @@ const tryCauseException = <E>(cause: Cause.Cause<E>, name: string): CauseExcepti
   }
 }
 
-export function reportError(
-  name: string
-) {
-  return (
-    cause: Cause.Cause<unknown>,
-    extras?: Record<string, unknown>,
-    level: LogLevel.Severity = "Error"
-  ) =>
-    Effect
-      .gen(function*() {
-        if (Cause.hasInterruptsOnly(cause)) {
-          yield* InfraLogger.logDebug("Interrupted").pipe(Effect.annotateLogs("extras", JSON.stringify(extras ?? {})))
-          return
-        }
-        const error = tryCauseException(cause, name)
-
-        yield* reportSentry(error, extras, LogLevelToSentry(level))
-        yield* InfraLogger
-          .logWithLevel(level, "Reporting error", cause)
-          .pipe(
-            Effect.annotateLogs(dropUndefined({
-              extras,
-              error: tryToReport(error),
-              cause: tryToJson(cause),
-              __error_name__: name
-            }))
-          )
-          .pipe(
-            Effect.catchCause((cause) => InfraLogger.logWarning("Failed to log error", cause)),
-            Effect.catchCause(() => InfraLogger.logFatal("Failed to log error cause"))
-          )
+export function reportError(name: string) {
+  return Effect.fnUntraced(
+    function*(
+      cause: Cause.Cause<unknown>,
+      extras?: Record<string, unknown>,
+      level: LogLevel.Severity = "Error"
+    ) {
+      if (Cause.hasInterruptsOnly(cause)) {
+        yield* InfraLogger.logDebug("Interrupted").pipe(Effect.annotateLogs("extras", JSON.stringify(extras ?? {})))
+        return
+      }
+      const error = tryCauseException(cause, name)
 
-        return error
-      })
-      .pipe(
-        Effect.tapCause((cause) =>
-          InfraLogger.logError("Failed to report error", cause).pipe(
-            Effect.tapCause(() => InfraLogger.logFatal("Failed to log error cause"))
-          )
+      yield* reportSentry(error, extras, LogLevelToSentry(level))
+      yield* InfraLogger
+        .logWithLevel(level, "Reporting error", cause)
+        .pipe(
+          Effect.annotateLogs(dropUndefined({
+            extras,
+            error: tryToReport(error),
+            cause: tryToJson(cause),
+            __error_name__: name
+          })),
+          Effect.catchCause((cause) => InfraLogger.logWarning("Failed to log error", cause)),
+          Effect.catchCause(() => InfraLogger.logFatal("Failed to log error cause"))
         )
-      )
+
+      return error
+    },
+    (effect) =>
+      Effect.tapCause(effect, (cause) =>
+        InfraLogger.logError("Failed to report error", cause).pipe(
+          Effect.tapCause(() => InfraLogger.logFatal("Failed to log error cause"))
+        ))
+  )
 }
 
 function reportSentry(
@@ -66,45 +60,39 @@ function reportSentry(
     scope.setLevel(level)
     if (context) scope.setContext("context", { ...context })
     if (extras) scope.setContext("extras", extras)
-    scope.setContext("error", { data: tryToReport(error) })
-    scope.setContext("cause", { data: tryToJson(error.originalCause) })
+    const squashed = Cause.squash(error.originalCause)
+    scope.setContext("mainError", tryToJson(squashed))
+    scope.setContext("error", tryToReport(error))
+    scope.setContext("cause", tryToJson(error.originalCause))
     Sentry.captureException(error, scope)
   }))
 }
 
-export function logError<E>(
-  name: string
-) {
-  return (cause: Cause.Cause<E>, extras?: Record<string, unknown>) =>
-    Effect
-      .gen(function*() {
-        if (Cause.hasInterruptsOnly(cause)) {
-          yield* InfraLogger.logDebug("Interrupted").pipe(Effect.annotateLogs(dropUndefined({ extras })))
-          return
-        }
-        yield* InfraLogger
-          .logWarning("Logging error", cause)
-          .pipe(
-            Effect.annotateLogs(dropUndefined({
-              extras,
-              cause: tryToJson(cause),
-              __error_name__: name
-            }))
-          )
-      })
-      .pipe(
-        Effect.tapCause(() => InfraLogger.logFatal("Failed to log error cause"))
-      )
+export function logError<E>(name: string) {
+  return Effect.fnUntraced(
+    function*(cause: Cause.Cause<E>, extras?: Record<string, unknown>) {
+      if (Cause.hasInterruptsOnly(cause)) {
+        yield* InfraLogger.logDebug("Interrupted").pipe(Effect.annotateLogs(dropUndefined({ extras })))
+        return
+      }
+      yield* InfraLogger
+        .logWarning("Logging error", cause)
+        .pipe(Effect.annotateLogs(dropUndefined({
+          extras,
+          cause: tryToJson(cause),
+          __error_name__: name
+        })))
+    },
+    (effect) => Effect.tapCause(effect, () => InfraLogger.logFatal("Failed to log error cause"))
+  )
 }
 
-export function reportMessage(message: string, extras?: Record<string, unknown>) {
-  return Effect.gen(function*() {
-    const context = yield* getRC
-    const scope = new Sentry.Scope()
-    if (context) scope.setContext("context", { ...context })
-    if (extras) scope.setContext("extras", extras)
-    Sentry.captureMessage(message, scope)
+export const reportMessage = Effect.fnUntraced(function*(message: string, extras?: Record<string, unknown>) {
+  const context = yield* getRC
+  const scope = new Sentry.Scope()
+  if (context) scope.setContext("context", { ...context })
+  if (extras) scope.setContext("extras", extras)
+  Sentry.captureMessage(message, scope)
 
-    console.warn(message, extras)
-  })
-}
+  console.warn(message, extras)
+})

package/src/logger/shared.ts

@@ -7,7 +7,7 @@ export function getRequestContextFromFiber(fiber: Fiber.Fiber<unknown, unknown>)
   const span = Option.fromNullishOr(fiber.currentSpan)
   const locale = fiber.getRef(LocaleRef)
   const namespace = fiber.getRef(storeId)
-  return new RequestContext({
+  return RequestContext.make({
     span: Option.map(span, (s) => ({ spanId: s.spanId, traceId: s.traceId, sampled: s.sampled })).pipe(
       Option.getOrElse(() => ({ spanId: "bogus", sampled: true, traceId: "bogus" }))
     ),

package/src/rateLimit.ts

@@ -21,7 +21,9 @@
 // }
 
 import { Array, type Duration, Effect, type NonEmptyArray } from "effect-app"
+import { dual } from "effect-app/Function"
 import type { Semaphore } from "effect/Semaphore"
+import type { Concurrency } from "effect/Types"
 
 /**
  * Executes the specified effect, acquiring the specified number of permits
@@ -45,36 +47,42 @@ export function SEM_withPermitsDuration(permits: number, duration: Duration.Dura
   }
 }
 
-export function batchPar<R, E, A, R2, E2, A2, T>(
-  n: number,
-  forEachItem: (item: T, iWithinBatch: number, batchI: number) => Effect.Effect<A, E, R>,
-  forEachBatch: (a: NonEmptyArray<A>, i: number) => Effect.Effect<A2, E2, R2>
-) {
-  return (items: Iterable<T>) =>
-    Effect.forEach(
-      Array.chunksOf(items, n),
-      (_, i) =>
-        Effect
-          .forEach(_, (_, j) => forEachItem(_, j, i), { concurrency: "inherit" })
-          .pipe(Effect.flatMap((_) => forEachBatch(_, i))),
-      { concurrency: "inherit" }
-    )
+export interface BatchOptions {
+  readonly concurrency?: Concurrency | undefined
 }
 
-export function batch<R, E, A, R2, E2, A2, T>(
-  n: number,
-  forEachItem: (item: T, iWithinBatch: number, batchI: number) => Effect.Effect<A, E, R>,
-  forEachBatch: (a: NonEmptyArray<A>, i: number) => Effect.Effect<A2, E2, R2>
-) {
-  return (items: Iterable<T>) =>
+export const batch: {
+  <T, A, E, R, A2, E2, R2>(
+    n: number,
+    forEachItem: (item: T, iWithinBatch: number, batchI: number) => Effect.Effect<A, E, R>,
+    forEachBatch: (a: NonEmptyArray<A>, i: number) => Effect.Effect<A2, E2, R2>,
+    options?: BatchOptions
+  ): (items: Iterable<T>) => Effect.Effect<Array<A2>, E | E2, R | R2>
+  <T, A, E, R, A2, E2, R2>(
+    items: Iterable<T>,
+    n: number,
+    forEachItem: (item: T, iWithinBatch: number, batchI: number) => Effect.Effect<A, E, R>,
+    forEachBatch: (a: NonEmptyArray<A>, i: number) => Effect.Effect<A2, E2, R2>,
+    options?: BatchOptions
+  ): Effect.Effect<Array<A2>, E | E2, R | R2>
+} = dual(
+  (args) => typeof args[0] !== "number",
+  <T, A, E, R, A2, E2, R2>(
+    items: Iterable<T>,
+    n: number,
+    forEachItem: (item: T, iWithinBatch: number, batchI: number) => Effect.Effect<A, E, R>,
+    forEachBatch: (a: NonEmptyArray<A>, i: number) => Effect.Effect<A2, E2, R2>,
+    options?: BatchOptions
+  ) =>
     Effect.forEach(
       Array.chunksOf(items, n),
       (_, i) =>
         Effect
           .forEach(_, (_, j) => forEachItem(_, j, i), { concurrency: "inherit" })
-          .pipe(Effect.flatMap((_) => forEachBatch(_, i)))
+          .pipe(Effect.flatMap((_) => forEachBatch(_, i))),
+      { concurrency: options?.concurrency }
     )
-}
+)
 
 // export function rateLimit(
 //   n: number,