effect 4.0.0-beta.103 → 4.0.0-beta.104

package/src/unstable/rpc/RpcClient.ts

@@ -1022,6 +1022,13 @@ export const layerProtocolHttp = (options: {
 export const makeProtocolSocket = (options?: {
   readonly retryTransientErrors?: boolean | undefined
   readonly retryPolicy?: Schedule.Schedule<any, Socket.SocketError> | undefined
+  /**
+   * Runs for each retried `SocketOpenError` when `retryTransientErrors` is enabled.
+   * Ping timeouts are also reported because the protocol classifies them as
+   * `SocketOpenError`. The returned `Effect<void>` cannot fail with a typed error
+   * or require services; defects are logged and ignored so retries can continue.
+   */
+  readonly onTransientError?: ((error: RpcClientError) => Effect.Effect<void>) | undefined
 }): Effect.Effect<
   Protocol["Service"],
   never,
@@ -1046,6 +1053,13 @@ export const makeProtocolSocket = (options?: {
 
     const broadcast = (response: FromServerEncoded) =>
       Effect.forEach(clientIds, (clientId) => writeResponse(clientId, response))
+    const broadcastError = (error: RpcClientError) => {
+      currentError = error
+      return broadcast({
+        _tag: "ClientProtocolError",
+        error
+      })
+    }
 
     yield* Effect.suspend(() => {
       parser = serialization.makeUnsafe()
@@ -1110,24 +1124,29 @@ export const makeProtocolSocket = (options?: {
       Effect.tapCause((cause) => {
         const error = Cause.findError(cause)
         const hasError = Result.isSuccess(error)
-        if (
-          options?.retryTransientErrors && hasError &&
-          error.success.reason._tag === "SocketOpenError"
-        ) {
-          return Effect.void
-        }
-        currentError = new RpcClientError({
+        const rpcError = new RpcClientError({
           reason: hasError ? error.success.reason : new RpcClientDefect({
             message: "Unknown socket error",
             cause: Cause.squash(cause)
           })
         })
-        return broadcast({
-          _tag: "ClientProtocolError",
-          error: currentError
-        })
+        if (
+          options?.retryTransientErrors && hasError &&
+          error.success.reason._tag === "SocketOpenError"
+        ) {
+          return (options.onTransientError?.(rpcError) ?? Effect.void).pipe(
+            Effect.ignoreCause({
+              log: true,
+              message: "RpcClient onTransientError hook failed"
+            })
+          )
+        }
+        return broadcastError(rpcError)
       }),
-      Effect.retry(options?.retryPolicy ?? defaultRetryPolicy),
+      Effect.retryOrElse(
+        options?.retryPolicy ?? defaultRetryPolicy,
+        (error) => broadcastError(new RpcClientError({ reason: error.reason }))
+      ),
       Effect.annotateLogs({
         module: "RpcClient",
         method: "makeProtocolSocket"
@@ -1190,6 +1209,13 @@ const makePinger = Effect.fnUntraced(function*<A, E, R>(writePing: Effect.Effect
  */
 export const layerProtocolSocket = (options?: {
   readonly retryTransientErrors?: boolean | undefined
+  /**
+   * Runs for each retried `SocketOpenError` when `retryTransientErrors` is enabled.
+   * Ping timeouts are also reported because the protocol classifies them as
+   * `SocketOpenError`. The returned `Effect<void>` cannot fail with a typed error
+   * or require services; defects are logged and ignored so retries can continue.
+   */
+  readonly onTransientError?: ((error: RpcClientError) => Effect.Effect<void>) | undefined
 }): Layer.Layer<
   Protocol,
   never,

package/src/unstable/rpc/RpcClientError.ts

@@ -22,7 +22,7 @@ const TypeId = "~effect/rpc/RpcClientError"
  * @category errors
  * @since 4.0.0
  */
-export class RpcClientDefect extends Schema.ErrorClass<RpcClientDefect>("effect/rpc/RpcClientError/RpcClientDefect")({
+export class RpcClientDefect extends Schema.Error<RpcClientDefect>("effect/rpc/RpcClientError/RpcClientDefect")({
   _tag: Schema.tag("RpcClientDefect"),
   message: Schema.String,
   cause: Schema.Defect()
@@ -35,7 +35,7 @@ export class RpcClientDefect extends Schema.ErrorClass<RpcClientDefect>("effect/
  * @category errors
  * @since 4.0.0
  */
-export class RpcClientError extends Schema.ErrorClass<RpcClientError>(TypeId)({
+export class RpcClientError extends Schema.Error<RpcClientError>(TypeId)({
   _tag: Schema.tag("RpcClientError"),
   reason: Schema.Union([
     WorkerErrorReason,

package/src/unstable/rpc/RpcSerialization.ts

@@ -128,7 +128,7 @@ export const makeNdjson = (options?: StreamOptions): RpcSerialization["Service"]
       }
       return ({
         decode: (bytes) => {
-          buffer += typeof bytes === "string" ? bytes : decoder.decode(bytes)
+          buffer += typeof bytes === "string" ? bytes : decoder.decode(bytes, { stream: true })
           let position = 0
           let nlIndex = buffer.indexOf("\n", position)
           const items: Array<unknown> = []

package/src/unstable/schema/VariantSchema.ts

@@ -26,6 +26,7 @@ import * as Struct_ from "../../Struct.ts"
 export const TypeId = "~effect/schema/VariantSchema"
 
 const cacheSymbol = Symbol.for(`${TypeId}/cache`)
+const defaultCacheSymbol = Symbol.for(`${TypeId}/defaultCache`)
 
 /**
  * Pipeable container of schema fields that can be extracted into per-variant
@@ -38,6 +39,8 @@ export interface Struct<in out A extends Field.Fields> extends Pipeable {
   readonly [TypeId]: A
   /** @internal */
   [cacheSymbol]?: Record<string, Schema.Top>
+  /** @internal */
+  [defaultCacheSymbol]?: Record<string, Schema.Top>
 }
 
 /**
@@ -87,7 +90,7 @@ export declare namespace Struct {
   export type Validate<A, Variant extends string> = {
     readonly [K in keyof A]: A[K] extends { readonly [TypeId]: infer _ } ? Validate<A[K], Variant> :
       A[K] extends Field<infer Config> ? [keyof Config] extends [Variant] ? {} : "field must have valid variants"
-      : {}
+      : unknown
   }
 }
 
@@ -144,7 +147,7 @@ export declare namespace Field {
    * @since 4.0.0
    */
   export type ConfigWithKeys<K extends string> = {
-    readonly [P in K]?: Schema.Top
+    readonly [P in K]?: Schema.Top | undefined
   }
 
   /**
@@ -214,14 +217,18 @@ const extract: {
       readonly isDefault?: boolean | undefined
     }
   ): Extract<V, A> => {
-    const cache = self[cacheSymbol] ?? (self[cacheSymbol] = Object.create(null))
-    const cacheKey = options?.isDefault === true ? "__default" : variant
-    if (Object.hasOwn(cache, cacheKey)) {
-      return cache[cacheKey] as any
+    const cache = options?.isDefault === true
+      ? self[defaultCacheSymbol] ?? (self[defaultCacheSymbol] = Object.create(null))
+      : self[cacheSymbol] ?? (self[cacheSymbol] = Object.create(null))
+    if (Object.hasOwn(cache, variant)) {
+      return cache[variant] as any
     }
     const fields: Record<string, any> = {}
     for (const key of Object.keys(self[TypeId])) {
       const value = self[TypeId][key]
+      if (value === undefined) {
+        continue
+      }
       if (TypeId in value) {
         if (options?.isDefault === true && Schema.isSchema(value)) {
           InternalRecord.assignProperty(fields, key, value)
@@ -230,14 +237,17 @@ const extract: {
         }
       } else if (FieldTypeId in value) {
         if (Object.hasOwn(value.schemas, variant)) {
-          InternalRecord.assignProperty(fields, key, value.schemas[variant])
+          const schema = value.schemas[variant]
+          if (schema !== undefined) {
+            InternalRecord.assignProperty(fields, key, schema)
+          }
         }
       } else {
         InternalRecord.assignProperty(fields, key, value)
       }
     }
     const schema = Schema.Struct(fields)
-    cache[cacheKey] = schema
+    cache[variant] = schema
     return schema as any
   }
 )
@@ -296,12 +306,13 @@ type MissingSelfGeneric<Params extends string = ""> =
  * @category models
  * @since 4.0.0
  */
-export interface Union<Members extends ReadonlyArray<Struct<any>>> extends
-  Schema.Union<
-    {
-      readonly [K in keyof Members]: [Members[K]] extends [Schema.Top] ? Members[K] : never
-    }
-  >
+export interface Union<Members extends ReadonlyArray<Struct<any>>, Default extends string = string>
+  extends
+    Schema.Union<
+      {
+        readonly [K in keyof Members]: Extract<Default, Members[K], true>
+      }
+    >
 {}
 
 /**
@@ -410,7 +421,7 @@ export const make = <
       }
   readonly Union: <const Members extends ReadonlyArray<Struct<any>>>(
     members: Members
-  ) => Union<Members> & Union.Variants<Members, Variants[number]>
+  ) => Union<Members, Default> & Union.Variants<Members, Variants[number]>
   readonly extract: {
     <V extends Variants[number]>(
       variant: V
@@ -469,7 +480,7 @@ export const make = <
     }
   }
   function UnionVariants(members: ReadonlyArray<Struct<any>>) {
-    return Union(members, options.variants)
+    return Union(members, options.defaultVariant, options.variants)
   }
   const fieldEvolve = dual(
     2,
@@ -582,11 +593,18 @@ const Field = <const A extends Field.Config>(schemas: A): Field<A> => {
   return self
 }
 
-const Union = <Members extends ReadonlyArray<Struct<any>>, Variants extends ReadonlyArray<string>>(
+const Union = <
+  Members extends ReadonlyArray<Struct<any>>,
+  Default extends string,
+  Variants extends ReadonlyArray<string>
+>(
   members: Members,
+  defaultVariant: Default,
   variants: Variants
 ) => {
-  const VariantUnion = Schema.Union(members.filter((member) => Schema.isSchema(member))) as any
+  const VariantUnion = Schema.Union(
+    members.map((member) => Schema.isSchema(member) ? member : extract(member, defaultVariant, { isDefault: true }))
+  ) as any
   for (const variant of variants) {
     Object.defineProperty(VariantUnion, variant, {
       value: Schema.Union(members.map((member) => extract(member, variant)))

package/src/unstable/socket/Socket.ts

@@ -220,7 +220,7 @@ export const isSocketError = (u: unknown): u is SocketError => Predicate.hasProp
  * @category errors
  * @since 4.0.0
  */
-export class SocketReadError extends Schema.ErrorClass<SocketReadError>("effect/socket/Socket/SocketReadError")({
+export class SocketReadError extends Schema.Error<SocketReadError>("effect/socket/Socket/SocketReadError")({
   _tag: Schema.tag("SocketReadError"),
   cause: Schema.Defect()
 }) {
@@ -238,7 +238,7 @@ export class SocketReadError extends Schema.ErrorClass<SocketReadError>("effect/
  * @category errors
  * @since 4.0.0
  */
-export class SocketWriteError extends Schema.ErrorClass<SocketWriteError>("effect/socket/Socket/SocketWriteError")({
+export class SocketWriteError extends Schema.Error<SocketWriteError>("effect/socket/Socket/SocketWriteError")({
   _tag: Schema.tag("SocketWriteError"),
   cause: Schema.Defect()
 }) {
@@ -257,7 +257,7 @@ export class SocketWriteError extends Schema.ErrorClass<SocketWriteError>("effec
  * @category errors
  * @since 4.0.0
  */
-export class SocketOpenError extends Schema.ErrorClass<SocketOpenError>("effect/socket/Socket/SocketOpenError")({
+export class SocketOpenError extends Schema.Error<SocketOpenError>("effect/socket/Socket/SocketOpenError")({
   _tag: Schema.tag("SocketOpenError"),
   kind: Schema.Literals(["Unknown", "Timeout"]),
   cause: Schema.Defect()
@@ -281,7 +281,7 @@ export class SocketOpenError extends Schema.ErrorClass<SocketOpenError>("effect/
  * @category errors
  * @since 4.0.0
  */
-export class SocketCloseError extends Schema.ErrorClass<SocketCloseError>("effect/socket/Socket/SocketCloseError")({
+export class SocketCloseError extends Schema.Error<SocketCloseError>("effect/socket/Socket/SocketCloseError")({
   _tag: Schema.tag("SocketCloseError"),
   code: Schema.Int,
   closeReason: Schema.optional(Schema.String)
@@ -339,7 +339,7 @@ export type SocketErrorReason =
  * @category errors
  * @since 4.0.0
  */
-export class SocketError extends Schema.TaggedErrorClass<SocketError>(SocketErrorTypeId)("SocketError", {
+export class SocketError extends Schema.TaggedError<SocketError>(SocketErrorTypeId)("SocketError", {
   _tag: Schema.tag("SocketError"),
   reason: SocketErrorReason
 }) {
@@ -747,14 +747,21 @@ export const fromWebSocket = <RO>(
       )
 
     const write = (chunk: Uint8Array | string | CloseEvent) =>
-      latch.whenOpen(Effect.sync(() => {
-        const ws = currentWS!
-        if (isCloseEvent(chunk)) {
-          ws.close(chunk.code, chunk.reason)
-        } else {
-          ws.send(chunk as string | Uint8Array<ArrayBuffer>)
-        }
-      }))
+      latch.whenOpen(
+        Effect.suspend(() => {
+          try {
+            const ws = currentWS!
+            if (isCloseEvent(chunk)) {
+              ws.close(chunk.code, chunk.reason)
+            } else {
+              ws.send(chunk as string | Uint8Array<ArrayBuffer>)
+            }
+            return Effect.void
+          } catch (cause) {
+            return Effect.fail(new SocketError({ reason: new SocketWriteError({ cause }) }))
+          }
+        })
+      )
     const writer = Effect.succeed(write)
 
     return Effect.succeed(make({
@@ -917,7 +924,10 @@ export const fromTransformStream = <R>(acquire: Effect.Effect<InputTransformStre
             })
           )
         }
-        return Effect.promise(() => getWriter(stream).write(typeof chunk === "string" ? encoder.encode(chunk) : chunk))
+        return Effect.tryPromise({
+          try: () => getWriter(stream).write(typeof chunk === "string" ? encoder.encode(chunk) : chunk),
+          catch: (cause) => new SocketError({ reason: new SocketWriteError({ cause }) })
+        })
       }))
     const writer = Effect.acquireRelease(
       Effect.succeed(write),

package/src/unstable/sql/SqlClient.ts

@@ -16,6 +16,7 @@ import * as Option from "../../Option.ts"
 import type * as Queue from "../../Queue.ts"
 import type { ReadonlyRecord } from "../../Record.ts"
 import * as Scope from "../../Scope.ts"
+import * as Semaphore from "../../Semaphore.ts"
 import * as Stream from "../../Stream.ts"
 import * as Tracer from "../../Tracer.ts"
 import type { NoInfer } from "../../Types.ts"
@@ -126,6 +127,7 @@ export declare namespace SqlClient {
 }
 
 let clientIdCounter = 0
+let transactionSemaphoreIdCounter = 0
 
 /**
  * Constructs a `SqlClient` from connection acquirers, a compiler, transaction
@@ -227,66 +229,73 @@ export const makeWithTransaction = <I, S>(options: {
   readonly commit: (conn: NoInfer<S>) => Effect.Effect<void, SqlError>
   readonly rollback: (conn: NoInfer<S>) => Effect.Effect<void, SqlError>
   readonly rollbackSavepoint: (conn: NoInfer<S>, id: number) => Effect.Effect<void, SqlError>
-}) =>
-<R, E, A>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E | SqlError, R> => {
-  return Effect.uninterruptibleMask((restore) =>
-    Effect.useSpan(
-      "sql.transaction",
-      { kind: "client" },
-      (span) =>
-        Effect.withFiber<A, E | SqlError, R>((fiber) => {
-          for (const [key, value] of options.spanAttributes) {
-            span.attribute(key, value)
-          }
-          const services = fiber.context
-          const clock = fiber.getRef(Clock)
-          const connOption = Context.getOption(services, options.transactionService)
-          const conn = connOption._tag === "Some"
-            ? Effect.succeed([undefined, connOption.value[0]] as const)
-            : options.acquireConnection
-          const id = connOption._tag === "Some" ? connOption.value[1] + 1 : 0
-          return Effect.flatMap(
-            conn,
-            (
-              [scope, conn]
-            ) =>
-              (id === 0 ? options.begin(conn) : options.savepoint(conn, id)).pipe(
-                Effect.flatMap(() =>
-                  Effect.provideContext(
-                    restore(effect),
-                    services.pipe(
-                      Context.add(options.transactionService, [conn, id]),
-                      Context.add(Tracer.ParentSpan, span)
+}) => {
+  const transactionSemaphore = Context.Service<Semaphore.Semaphore>(
+    `effect/sql/SqlClient/TransactionSemaphore/${transactionSemaphoreIdCounter++}`
+  )
+  return <R, E, A>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E | SqlError, R> =>
+    Effect.uninterruptibleMask((restore) =>
+      Effect.useSpan(
+        "sql.transaction",
+        { kind: "client" },
+        (span) =>
+          Effect.withFiber<A, E | SqlError, R>((fiber) => {
+            for (const [key, value] of options.spanAttributes) {
+              span.attribute(key, value)
+            }
+            const services = fiber.context
+            const clock = fiber.getRef(Clock)
+            const connOption = Context.getOption(services, options.transactionService)
+            const conn = connOption._tag === "Some"
+              ? Effect.succeed([undefined, connOption.value[0]] as const)
+              : options.acquireConnection
+            const id = connOption._tag === "Some" ? connOption.value[1] + 1 : 0
+            const transaction = Effect.flatMap(
+              conn,
+              (
+                [scope, conn]
+              ) =>
+                (id === 0 ? options.begin(conn) : options.savepoint(conn, id)).pipe(
+                  Effect.flatMap(() =>
+                    Effect.provideContext(
+                      restore(effect),
+                      services.pipe(
+                        Context.add(options.transactionService, [conn, id]),
+                        Context.add(transactionSemaphore, Semaphore.makeUnsafe(1)),
+                        Context.add(Tracer.ParentSpan, span)
+                      )
                     )
-                  )
-                ),
-                Effect.exit,
-                Effect.flatMap((exit) => {
-                  let effect: Effect.Effect<void>
-                  if (Exit.isSuccess(exit)) {
-                    if (id === 0) {
-                      span.event("db.transaction.commit", clock.currentTimeNanosUnsafe())
-                      effect = Effect.orDie(options.commit(conn))
+                  ),
+                  Effect.exit,
+                  Effect.flatMap((exit) => {
+                    let effect: Effect.Effect<void>
+                    if (Exit.isSuccess(exit)) {
+                      if (id === 0) {
+                        span.event("db.transaction.commit", clock.currentTimeNanosUnsafe())
+                        effect = Effect.orDie(options.commit(conn))
+                      } else {
+                        span.event("db.transaction.savepoint", clock.currentTimeNanosUnsafe())
+                        effect = Effect.void
+                      }
                     } else {
-                      span.event("db.transaction.savepoint", clock.currentTimeNanosUnsafe())
-                      effect = Effect.void
+                      span.event("db.transaction.rollback", clock.currentTimeNanosUnsafe())
+                      effect = Effect.orDie(
+                        id > 0
+                          ? options.rollbackSavepoint(conn, id)
+                          : options.rollback(conn)
+                      )
                     }
-                  } else {
-                    span.event("db.transaction.rollback", clock.currentTimeNanosUnsafe())
-                    effect = Effect.orDie(
-                      id > 0
-                        ? options.rollbackSavepoint(conn, id)
-                        : options.rollback(conn)
-                    )
-                  }
-                  const withScope = scope !== undefined ? Effect.ensuring(effect, Scope.close(scope, exit)) : effect
-                  return Effect.flatMap(withScope, () => exit)
-                })
-              )
-          )
-        })
+                    const withScope = scope !== undefined ? Effect.ensuring(effect, Scope.close(scope, exit)) : effect
+                    return Effect.flatMap(withScope, () => exit)
+                  })
+                )
+            )
+            return id === 0
+              ? transaction
+              : Context.getUnsafe(services, transactionSemaphore).withPermit(transaction)
+          })
+      )
     )
-  )
 }
 
 /**

package/src/unstable/sql/SqlError.ts

@@ -28,7 +28,7 @@ const ReasonFields = {
  * @category errors
  * @since 4.0.0
  */
-export class ConnectionError extends Schema.TaggedErrorClass<ConnectionError>("effect/sql/SqlError/ConnectionError")(
+export class ConnectionError extends Schema.TaggedError<ConnectionError>("effect/sql/SqlError/ConnectionError")(
   "ConnectionError",
   ReasonFields
 ) {
@@ -56,7 +56,7 @@ export class ConnectionError extends Schema.TaggedErrorClass<ConnectionError>("e
  * @category errors
  * @since 4.0.0
  */
-export class AuthenticationError extends Schema.TaggedErrorClass<AuthenticationError>(
+export class AuthenticationError extends Schema.TaggedError<AuthenticationError>(
   "effect/sql/SqlError/AuthenticationError"
 )("AuthenticationError", ReasonFields) {
   /**
@@ -83,7 +83,7 @@ export class AuthenticationError extends Schema.TaggedErrorClass<AuthenticationE
  * @category errors
  * @since 4.0.0
  */
-export class AuthorizationError extends Schema.TaggedErrorClass<AuthorizationError>(
+export class AuthorizationError extends Schema.TaggedError<AuthorizationError>(
   "effect/sql/SqlError/AuthorizationError"
 )("AuthorizationError", ReasonFields) {
   /**
@@ -109,7 +109,7 @@ export class AuthorizationError extends Schema.TaggedErrorClass<AuthorizationErr
  * @category errors
  * @since 4.0.0
  */
-export class SqlSyntaxError extends Schema.TaggedErrorClass<SqlSyntaxError>("effect/sql/SqlError/SqlSyntaxError")(
+export class SqlSyntaxError extends Schema.TaggedError<SqlSyntaxError>("effect/sql/SqlError/SqlSyntaxError")(
   "SqlSyntaxError",
   ReasonFields
 ) {
@@ -142,7 +142,7 @@ const UniqueViolationFields = {
  * @category errors
  * @since 4.0.0
  */
-export class UniqueViolation extends Schema.TaggedErrorClass<UniqueViolation>("effect/sql/SqlError/UniqueViolation")(
+export class UniqueViolation extends Schema.TaggedError<UniqueViolation>("effect/sql/SqlError/UniqueViolation")(
   "UniqueViolation",
   UniqueViolationFields
 ) {
@@ -169,7 +169,7 @@ export class UniqueViolation extends Schema.TaggedErrorClass<UniqueViolation>("e
  * @category errors
  * @since 4.0.0
  */
-export class ConstraintError extends Schema.TaggedErrorClass<ConstraintError>("effect/sql/SqlError/ConstraintError")(
+export class ConstraintError extends Schema.TaggedError<ConstraintError>("effect/sql/SqlError/ConstraintError")(
   "ConstraintError",
   ReasonFields
 ) {
@@ -196,7 +196,7 @@ export class ConstraintError extends Schema.TaggedErrorClass<ConstraintError>("e
  * @category errors
  * @since 4.0.0
  */
-export class DeadlockError extends Schema.TaggedErrorClass<DeadlockError>("effect/sql/SqlError/DeadlockError")(
+export class DeadlockError extends Schema.TaggedError<DeadlockError>("effect/sql/SqlError/DeadlockError")(
   "DeadlockError",
   ReasonFields
 ) {
@@ -224,7 +224,7 @@ export class DeadlockError extends Schema.TaggedErrorClass<DeadlockError>("effec
  * @category errors
  * @since 4.0.0
  */
-export class SerializationError extends Schema.TaggedErrorClass<SerializationError>(
+export class SerializationError extends Schema.TaggedError<SerializationError>(
   "effect/sql/SqlError/SerializationError"
 )("SerializationError", ReasonFields) {
   /**
@@ -251,7 +251,7 @@ export class SerializationError extends Schema.TaggedErrorClass<SerializationErr
  * @category errors
  * @since 4.0.0
  */
-export class LockTimeoutError extends Schema.TaggedErrorClass<LockTimeoutError>("effect/sql/SqlError/LockTimeoutError")(
+export class LockTimeoutError extends Schema.TaggedError<LockTimeoutError>("effect/sql/SqlError/LockTimeoutError")(
   "LockTimeoutError",
   ReasonFields
 ) {
@@ -278,7 +278,7 @@ export class LockTimeoutError extends Schema.TaggedErrorClass<LockTimeoutError>(
  * @category errors
  * @since 4.0.0
  */
-export class StatementTimeoutError extends Schema.TaggedErrorClass<StatementTimeoutError>(
+export class StatementTimeoutError extends Schema.TaggedError<StatementTimeoutError>(
   "effect/sql/SqlError/StatementTimeoutError"
 )("StatementTimeoutError", ReasonFields) {
   /**
@@ -304,7 +304,7 @@ export class StatementTimeoutError extends Schema.TaggedErrorClass<StatementTime
  * @category errors
  * @since 4.0.0
  */
-export class UnknownError extends Schema.TaggedErrorClass<UnknownError>("effect/sql/SqlError/UnknownError")(
+export class UnknownError extends Schema.TaggedError<UnknownError>("effect/sql/SqlError/UnknownError")(
   "UnknownError",
   ReasonFields
 ) {
@@ -384,7 +384,7 @@ export const SqlErrorReason: Schema.Union<[
  * @category errors
  * @since 4.0.0
  */
-export class SqlError extends Schema.TaggedErrorClass<SqlError>("effect/sql/SqlError")("SqlError", {
+export class SqlError extends Schema.TaggedError<SqlError>("effect/sql/SqlError")("SqlError", {
   reason: SqlErrorReason
 }) {
   /**
@@ -574,7 +574,7 @@ export const classifySqliteError = (
  * @since 4.0.0
  */
 export class ResultLengthMismatch
-  extends Schema.TaggedErrorClass<ResultLengthMismatch>("effect/sql/ResultLengthMismatch")("ResultLengthMismatch", {
+  extends Schema.TaggedError<ResultLengthMismatch>("effect/sql/ResultLengthMismatch")("ResultLengthMismatch", {
     expected: Schema.Natural,
     actual: Schema.Natural
   })

package/src/unstable/sql/SqlResolver.ts

@@ -133,7 +133,7 @@ export const ordered = <Req extends Schema.Constraint, Res extends Schema.Constr
   >({
     key: transactionKey,
     resolver: Effect.fnUntraced(function*(entries) {
-      const inputs = yield* partitionRequests(entries, options.Request)
+      const [inputs, encodedEntries] = yield* partitionRequests(entries, options.Request)
       const results = yield* options.execute(inputs as any).pipe(
         Effect.provideContext(entries[0].context)
       )
@@ -143,8 +143,8 @@ export const ordered = <Req extends Schema.Constraint, Res extends Schema.Constr
       const decodedResults = yield* decodeArray(results).pipe(
         Effect.provideContext(entries[0].context)
       )
-      for (let i = 0; i < entries.length; i++) {
-        entries[i].completeUnsafe(Exit.succeed(decodedResults[i]))
+      for (let i = 0; i < encodedEntries.length; i++) {
+        encodedEntries[i].completeUnsafe(Exit.succeed(decodedResults[i]))
       }
     })
   })
@@ -189,7 +189,7 @@ export const grouped = <Req extends Schema.Constraint, Res extends Schema.Constr
   >({
     key: transactionKey,
     resolver: Effect.fnUntraced(function*(entries) {
-      const inputs = yield* partitionRequests(entries, options.Request)
+      const [inputs] = yield* partitionRequests(entries, options.Request)
       const resultMap = MutableHashMap.empty<K, Arr.NonEmptyArray<Res["Type"]>>()
       const results = yield* options.execute(inputs as any).pipe(
         Effect.provideContext(entries[0].context)
@@ -310,7 +310,7 @@ const void_ = <Req extends Schema.Constraint, _, E, R>(
   >({
     key: transactionKey,
     resolver: Effect.fnUntraced(function*(entries) {
-      const inputs = yield* partitionRequests(entries, options.Request)
+      const [inputs] = yield* partitionRequests(entries, options.Request)
       yield* options.execute(inputs as any).pipe(
         Effect.provideContext(entries[0].context)
       )
@@ -338,6 +338,7 @@ const partitionRequests = function*<In, A, E, R, InE>(
 ) {
   const len = requests.length
   const inputs = Arr.empty<InE>()
+  const encodedEntries = Arr.empty<Request.Entry<SqlRequest<In, A, E, R>>>()
   let entry!: Request.Entry<SqlRequest<In, A, E, R>>
   const encode = Schema.encodeEffect(schema)
   const handle = Effect.matchCauseEager({
@@ -346,6 +347,7 @@ const partitionRequests = function*<In, A, E, R, InE>(
     },
     onSuccess(value: InE) {
       inputs.push(value)
+      encodedEntries.push(entry)
     }
   })
 
@@ -354,7 +356,7 @@ const partitionRequests = function*<In, A, E, R, InE>(
     yield (Effect.provideContext(handle(encode(entry.request.payload)), entry.context) as Effect.Effect<void>)
   }
 
-  return inputs
+  return [inputs, encodedEntries] as const
 }
 
 const partitionRequestsById = function*<In, A, E, R, InE>(