effect 4.0.0-beta.6 → 4.0.0-beta.62

package/src/unstable/sql/SqlModel.ts

@@ -3,15 +3,13 @@
  * @category models
  */
 import type * as Cause from "../../Cause.ts"
-import type { DurationInput } from "../../Duration.ts"
 import * as Effect from "../../Effect.ts"
-import { identity } from "../../Function.ts"
 import * as RequestResolver from "../../RequestResolver.ts"
 import type * as Schema from "../../Schema.ts"
 import type { Scope } from "../../Scope.ts"
 import type * as Model from "../schema/Model.ts"
 import { SqlClient } from "./SqlClient.ts"
-import type { SqlError } from "./SqlError.ts"
+import type { ResultLengthMismatch, SqlError } from "./SqlError.ts"
 import * as SqlResolver from "./SqlResolver.ts"
 import * as SqlSchema from "./SqlSchema.ts"
 
@@ -69,7 +67,7 @@ export const makeRepository = <
     const idSchema = Model.fields[options.idColumn] as Schema.Top
     const idColumn = options.idColumn as string
 
-    const insertSchema = SqlSchema.single({
+    const insertSchema = SqlSchema.findOne({
       Request: Model.insert,
       Result: Model,
       execute: (request) =>
@@ -107,7 +105,7 @@ select * from ${sql(options.tableName)} where ${sql(idColumn)} = LAST_INSERT_ID(
         })
       ) as any
 
-    const updateSchema = SqlSchema.single({
+    const updateSchema = SqlSchema.findOne({
       Request: Model.update,
       Result: Model,
       execute: (request: any) =>
@@ -159,7 +157,7 @@ select * from ${sql(options.tableName)} where ${sql(idColumn)} = ${request[idCol
         })
       ) as any
 
-    const findByIdSchema = SqlSchema.single({
+    const findByIdSchema = SqlSchema.findOne({
       Request: idSchema,
       Result: Model,
       execute: (id: any) => sql`select * from ${sql(options.tableName)} where ${sql(idColumn)} = ${id}`
@@ -201,7 +199,7 @@ select * from ${sql(options.tableName)} where ${sql(idColumn)} = ${request[idCol
  * @since 4.0.0
  * @category repository
  */
-export const makeDataLoaders = <
+export const makeResolvers = <
   S extends Model.Any,
   Id extends (keyof S["Type"]) & (keyof S["update"]["Type"]) & (keyof S["fields"])
 >(
@@ -210,31 +208,36 @@ export const makeDataLoaders = <
     readonly tableName: string
     readonly spanPrefix: string
     readonly idColumn: Id
-    readonly window: DurationInput
-    readonly maxBatchSize?: number | undefined
   }
 ): Effect.Effect<
   {
-    readonly insert: (
-      insert: S["insert"]["Type"]
-    ) => Effect.Effect<
-      S["Type"],
-      SqlError | Schema.SchemaError,
-      S["DecodingServices"] | S["insert"]["EncodingServices"]
+    readonly insert: RequestResolver.RequestResolver<
+      SqlResolver.SqlRequest<
+        S["insert"]["Type"],
+        S["Type"],
+        ResultLengthMismatch | SqlError,
+        S["insert"]["EncodingServices"]
+      >
     >
-    readonly insertVoid: (
-      insert: S["insert"]["Type"]
-    ) => Effect.Effect<void, SqlError | Schema.SchemaError, S["insert"]["EncodingServices"]>
-    readonly findById: (
-      id: S["fields"][Id]["Type"]
-    ) => Effect.Effect<
-      S["Type"],
-      SqlError | Schema.SchemaError | Cause.NoSuchElementError,
-      S["DecodingServices"] | S["fields"][Id]["EncodingServices"]
+    readonly insertVoid: RequestResolver.RequestResolver<
+      SqlResolver.SqlRequest<S["insert"]["Type"], void, SqlError, S["insert"]["EncodingServices"]>
+    >
+    readonly findById: RequestResolver.RequestResolver<
+      SqlResolver.SqlRequest<
+        S["fields"][Id]["Type"],
+        S["Type"],
+        Cause.NoSuchElementError | SqlError,
+        S["DecodingServices"] | S["fields"][Id]["EncodingServices"]
+      >
+    >
+    readonly delete: RequestResolver.RequestResolver<
+      SqlResolver.SqlRequest<
+        S["fields"][Id]["Type"],
+        void,
+        SqlError,
+        S["fields"][Id]["EncodingServices"]
+      >
     >
-    readonly delete: (
-      id: S["fields"][Id]["Type"]
-    ) => Effect.Effect<void, SqlError | Schema.SchemaError, S["fields"][Id]["EncodingServices"]>
   },
   never,
   SqlClient | Scope
@@ -243,9 +246,15 @@ export const makeDataLoaders = <
     const sql = yield* SqlClient
     const idSchema = Model.fields[options.idColumn] as Schema.Top
     const idColumn = options.idColumn as string
-    const setMaxBatchSize = options.maxBatchSize ? RequestResolver.batchN(options.maxBatchSize) : identity
 
-    const insertResolver = SqlResolver.ordered({
+    const insert: RequestResolver.RequestResolver<
+      SqlResolver.SqlRequest<
+        S["insert"]["Type"],
+        S["Type"],
+        ResultLengthMismatch | SqlError,
+        S["DecodingServices"] | S["insert"]["EncodingServices"]
+      >
+    > = SqlResolver.ordered({
       Request: Model.insert,
       Result: Model,
       execute: (request: any) =>
@@ -259,44 +268,26 @@ select * from ${sql(options.tableName)} where ${sql(idColumn)} = LAST_INSERT_ID(
           orElse: () => sql`insert into ${sql(options.tableName)} ${sql.insert(request).returning("*")}`
         })
     }).pipe(
-      RequestResolver.setDelay(options.window),
-      setMaxBatchSize,
       RequestResolver.withSpan(`${options.spanPrefix}.insertResolver`)
     )
-    const insertExecute = SqlResolver.request(insertResolver)
-    const insert = (
-      insert: S["insert"]["Type"]
-    ): Effect.Effect<
-      S["Type"],
-      SqlError | Schema.SchemaError,
-      S["DecodingServices"] | S["insert"]["EncodingServices"]
-    > =>
-      insertExecute(insert).pipe(
-        Effect.catchTag("ResultLengthMismatch", Effect.die),
-        Effect.withSpan(`${options.spanPrefix}.insert`, {}, {
-          captureStackTrace: false
-        })
-      ) as any
 
-    const insertVoidResolver = SqlResolver.void({
+    const insertVoid: RequestResolver.RequestResolver<
+      SqlResolver.SqlRequest<S["insert"]["Type"], void, Schema.SchemaError | SqlError, S["insert"]["EncodingServices"]>
+    > = SqlResolver.void({
       Request: Model.insert,
       execute: (request: any) => sql`insert into ${sql(options.tableName)} ${sql.insert(request)}`
     }).pipe(
-      RequestResolver.setDelay(options.window),
-      setMaxBatchSize,
       RequestResolver.withSpan(`${options.spanPrefix}.insertVoidResolver`)
     )
-    const insertVoidExecute = SqlResolver.request(insertVoidResolver)
-    const insertVoid = (
-      insert: S["insert"]["Type"]
-    ): Effect.Effect<void, SqlError | Schema.SchemaError, S["insert"]["EncodingServices"]> =>
-      insertVoidExecute(insert).pipe(
-        Effect.withSpan(`${options.spanPrefix}.insertVoid`, {}, {
-          captureStackTrace: false
-        })
-      ) as any
 
-    const findByIdResolver = SqlResolver.findById({
+    const findById: RequestResolver.RequestResolver<
+      SqlResolver.SqlRequest<
+        S["fields"][Id]["Type"],
+        S["Type"],
+        Cause.NoSuchElementError | Schema.SchemaError | SqlError,
+        S["DecodingServices"] | S["fields"][Id]["EncodingServices"]
+      >
+    > = SqlResolver.findById({
       Id: idSchema,
       Result: Model,
       ResultId(request: any) {
@@ -304,41 +295,22 @@ select * from ${sql(options.tableName)} where ${sql(idColumn)} = LAST_INSERT_ID(
       },
       execute: (ids: any) => sql`select * from ${sql(options.tableName)} where ${sql.in(idColumn, ids)}`
     }).pipe(
-      RequestResolver.setDelay(options.window),
-      setMaxBatchSize,
       RequestResolver.withSpan(`${options.spanPrefix}.findByIdResolver`)
     )
-    const findByIdExecute = SqlResolver.request(findByIdResolver)
-    const findById = (
-      id: S["fields"][Id]["Type"]
-    ): Effect.Effect<
-      S["Type"],
-      Cause.NoSuchElementError | SqlError | Schema.SchemaError,
-      S["DecodingServices"] | S["fields"][Id]["EncodingServices"]
-    > =>
-      findByIdExecute(id).pipe(
-        Effect.withSpan(`${options.spanPrefix}.findById`, { attributes: { id } }, {
-          captureStackTrace: false
-        })
-      ) as any
 
-    const deleteResolver = SqlResolver.void({
+    const delete_: RequestResolver.RequestResolver<
+      SqlResolver.SqlRequest<
+        S["fields"][Id]["Type"],
+        void,
+        Schema.SchemaError | SqlError,
+        S["fields"][Id]["EncodingServices"]
+      >
+    > = SqlResolver.void({
       Request: idSchema,
       execute: (ids: any) => sql`delete from ${sql(options.tableName)} where ${sql.in(idColumn, ids)}`
     }).pipe(
-      RequestResolver.setDelay(options.window),
-      setMaxBatchSize,
       RequestResolver.withSpan(`${options.spanPrefix}.deleteResolver`)
     )
-    const deleteExecute = SqlResolver.request(deleteResolver)
-    const delete_ = (
-      id: S["fields"][Id]["Type"]
-    ): Effect.Effect<void, SqlError | Schema.SchemaError, S["fields"][Id]["EncodingServices"]> =>
-      deleteExecute(id).pipe(
-        Effect.withSpan(`${options.spanPrefix}.delete`, { attributes: { id } }, {
-          captureStackTrace: false
-        })
-      ) as any
 
     return { insert, insertVoid, findById, delete: delete_ } as const
   })

package/src/unstable/sql/SqlResolver.ts

@@ -57,9 +57,9 @@ export const request: {
 } = function() {
   if (arguments.length === 1) {
     const resolver = arguments[0]
-    return (payload: any) => Effect.request(SqlRequest(payload), Effect.succeed(resolver))
+    return (payload: any) => Effect.request(SqlRequest(payload), resolver)
   }
-  return Effect.request(SqlRequest(arguments[0]), Effect.succeed(arguments[1]))
+  return Effect.request(SqlRequest(arguments[0]), arguments[1])
 } as any
 
 /**
@@ -102,19 +102,19 @@ export const ordered = <Req extends Schema.Top, Res extends Schema.Top, _, E, R>
       E | ResultLengthMismatch,
       Req["EncodingServices"] | Res["DecodingServices"] | R
     >,
-    SqlClient.TransactionConnection["Service"] | undefined
+    SqlClient.TransactionConnection.Service | undefined
   >({
-    key: (entry) => entry.services.mapUnsafe.get(SqlClient.TransactionConnection.key),
+    key: transactionKey,
     resolver: Effect.fnUntraced(function*(entries) {
       const inputs = yield* partitionRequests(entries, options.Request)
       const results = yield* options.execute(inputs as any).pipe(
-        Effect.provideServices(entries[0].services)
+        Effect.provideContext(entries[0].context)
       )
       if (results.length !== inputs.length) {
-        return yield* Effect.fail(new ResultLengthMismatch({ expected: inputs.length, actual: results.length }))
+        return yield* new ResultLengthMismatch({ expected: inputs.length, actual: results.length })
       }
       const decodedResults = yield* decodeArray(results).pipe(
-        Effect.provideServices(entries[0].services)
+        Effect.provideContext(entries[0].context)
       )
       for (let i = 0; i < entries.length; i++) {
         entries[i].completeUnsafe(Exit.succeed(decodedResults[i]))
@@ -158,17 +158,17 @@ export const grouped = <Req extends Schema.Top, Res extends Schema.Top, K, Row,
       E | Schema.SchemaError | Cause.NoSuchElementError,
       Req["EncodingServices"] | Res["DecodingServices"] | R
     >,
-    SqlClient.TransactionConnection["Service"] | undefined
+    SqlClient.TransactionConnection.Service | undefined
   >({
-    key: (entry) => entry.services.mapUnsafe.get(SqlClient.TransactionConnection.key),
+    key: transactionKey,
     resolver: Effect.fnUntraced(function*(entries) {
       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.provideServices(entries[0].services)
+        Effect.provideContext(entries[0].context)
       )
       const decodedResults = yield* decodeResults(results).pipe(
-        Effect.provideServices(entries[0].services)
+        Effect.provideContext(entries[0].context)
       )
       for (let i = 0, len = decodedResults.length; i < len; i++) {
         const result = decodedResults[i]
@@ -224,16 +224,16 @@ export const findById = <Id extends Schema.Top, Res extends Schema.Top, Row, E,
       E | Schema.SchemaError | Cause.NoSuchElementError,
       Id["EncodingServices"] | Res["DecodingServices"] | R
     >,
-    SqlClient.TransactionConnection["Service"] | undefined
+    SqlClient.TransactionConnection.Service | undefined
   >({
-    key: (entry) => entry.services.mapUnsafe.get(SqlClient.TransactionConnection.key),
+    key: transactionKey,
     resolver: Effect.fnUntraced(function*(entries) {
       const [inputs, idMap] = yield* partitionRequestsById(entries, options.Id)
       const results = yield* options.execute(inputs as any).pipe(
-        Effect.provideServices(entries[0].services)
+        Effect.provideContext(entries[0].context)
       )
       const decodedResults = yield* decodeResults(results).pipe(
-        Effect.provideServices(entries[0].services)
+        Effect.provideContext(entries[0].context)
       )
       for (let i = 0; i < decodedResults.length; i++) {
         const result = decodedResults[i]
@@ -277,13 +277,13 @@ const void_ = <Req extends Schema.Top, _, E, R>(
       E | Schema.SchemaError,
       Req["EncodingServices"] | R
     >,
-    SqlClient.TransactionConnection["Service"] | undefined
+    SqlClient.TransactionConnection.Service | undefined
   >({
-    key: (entry) => entry.services.mapUnsafe.get(SqlClient.TransactionConnection.key),
+    key: transactionKey,
     resolver: Effect.fnUntraced(function*(entries) {
       const inputs = yield* partitionRequests(entries, options.Request)
       yield* options.execute(inputs as any).pipe(
-        Effect.provideServices(entries[0].services)
+        Effect.provideContext(entries[0].context)
       )
       for (let i = 0; i < entries.length; i++) {
         entries[i].completeUnsafe(Exit.void)
@@ -322,7 +322,7 @@ const partitionRequests = function*<In, A, E, R, InE>(
 
   for (let i = 0; i < len; i++) {
     entry = requests[i]
-    yield (Effect.provideServices(handle(encode(entry.request.payload)), entry.services) as Effect.Effect<void>)
+    yield (Effect.provideContext(handle(encode(entry.request.payload)), entry.context) as Effect.Effect<void>)
   }
 
   return inputs
@@ -348,9 +348,17 @@ const partitionRequestsById = function*<In, A, E, R, InE>(
 
   for (let i = 0; i < len; i++) {
     entry = requests[i]
-    yield (Effect.provideServices(handle(encode(entry.request.payload)), entry.services) as Effect.Effect<void>)
+    yield (Effect.provideContext(handle(encode(entry.request.payload)), entry.context) as Effect.Effect<void>)
     MutableHashMap.set(byIdMap, entry.request.payload, entry)
   }
 
   return [inputs, byIdMap] as const
 }
+
+function transactionKey<A>(entry: Request.Entry<A>): SqlClient.TransactionConnection.Service | undefined {
+  const client = entry.context.mapUnsafe.get(SqlClient.SqlClient.key)
+  if (!client) return undefined
+  const conn = entry.context.mapUnsafe.get(client.transactionService.key)
+  if (!conn) return undefined
+  return Equal.byReferenceUnsafe(conn)
+}

package/src/unstable/sql/SqlSchema.ts

@@ -13,7 +13,7 @@ import * as Schema from "../../Schema.ts"
  * @since 4.0.0
  * @category constructor
  */
-export const findMany = <Req extends Schema.Top, Res extends Schema.Top, E, R>(
+export const findAll = <Req extends Schema.Top, Res extends Schema.Top, E, R>(
   options: {
     readonly Request: Req
     readonly Result: Res
@@ -21,25 +21,41 @@ export const findMany = <Req extends Schema.Top, Res extends Schema.Top, E, R>(
   }
 ) => {
   const encodeRequest = Schema.encodeEffect(options.Request)
-  const decode = Schema.decodeUnknownEffect(Schema.Array(options.Result))
+  const decode = Schema.decodeUnknownEffect(Schema.mutable(Schema.Array(options.Result)))
   return (
-    request: Req["Encoded"]
+    request: Req["Type"]
+  ): Effect.Effect<
+    Array<Res["Type"]>,
+    E | Schema.SchemaError,
+    Req["EncodingServices"] | Res["DecodingServices"] | R
+  > => Effect.flatMap(Effect.flatMap(encodeRequest(request), options.execute), decode)
+}
+
+/**
+ * Run a sql query with a request schema and a result schema.
+ *
+ * @since 4.0.0
+ * @category constructor
+ */
+export const findNonEmpty = <Req extends Schema.Top, Res extends Schema.Top, E, R>(
+  options: {
+    readonly Request: Req
+    readonly Result: Res
+    readonly execute: (request: Req["Encoded"]) => Effect.Effect<ReadonlyArray<unknown>, E, R>
+  }
+) => {
+  const find = findAll(options)
+  return (
+    request: Req["Type"]
   ): Effect.Effect<
     Arr.NonEmptyArray<Res["Type"]>,
     E | Schema.SchemaError | Cause.NoSuchElementError,
     Req["EncodingServices"] | Res["DecodingServices"] | R
   > =>
-    Effect.flatMap(
-      Effect.flatMap(encodeRequest(request), options.execute),
-      (results): Effect.Effect<
-        Arr.NonEmptyArray<Res["Type"]>,
-        Schema.SchemaError | Cause.NoSuchElementError,
-        Req["EncodingServices"] | Res["DecodingServices"]
-      > =>
-        Arr.isReadonlyArrayNonEmpty(results)
-          ? decode(results) as Effect.Effect<Arr.NonEmptyArray<Res["Type"]>, Schema.SchemaError>
-          : Effect.fail(new Cause.NoSuchElementError())
-    )
+    Effect.flatMap(find(request), (results) =>
+      Arr.isArrayNonEmpty(results)
+        ? Effect.succeed(results)
+        : Effect.fail(new Cause.NoSuchElementError()))
 }
 
 const void_ = <Req extends Schema.Top, E, R>(
@@ -65,7 +81,7 @@ export {
 }
 
 /**
- * Run a sql query with a request schema and a result schema and return the first result, if any.
+ * Run a sql query with a request schema and a result schema and return the first result.
  *
  * @since 4.0.0
  * @category constructor
@@ -82,17 +98,17 @@ export const findOne = <Req extends Schema.Top, Res extends Schema.Top, E, R>(
   return (
     request: Req["Type"]
   ): Effect.Effect<
-    Option.Option<Res["Type"]>,
-    E | Schema.SchemaError,
+    Res["Type"],
+    E | Schema.SchemaError | Cause.NoSuchElementError,
     R | Req["EncodingServices"] | Res["DecodingServices"]
   > =>
     Effect.flatMap(
       Effect.flatMap(encodeRequest(request), options.execute),
       (arr): Effect.Effect<
-        Option.Option<Res["Type"]>,
-        Schema.SchemaError,
+        Res["Type"],
+        Schema.SchemaError | Cause.NoSuchElementError,
         Req["EncodingServices"] | Res["DecodingServices"]
-      > => Arr.isReadonlyArrayNonEmpty(arr) ? Effect.asSome(decode(arr[0])) : Effect.succeedNone
+      > => Arr.isReadonlyArrayNonEmpty(arr) ? decode(arr[0]) : Effect.fail(new Cause.NoSuchElementError())
     )
 }
 
@@ -102,7 +118,7 @@ export const findOne = <Req extends Schema.Top, Res extends Schema.Top, E, R>(
  * @since 4.0.0
  * @category constructor
  */
-export const single = <Req extends Schema.Top, Res extends Schema.Top, E, R>(
+export const findOneOption = <Req extends Schema.Top, Res extends Schema.Top, E, R>(
   options: {
     readonly Request: Req
     readonly Result: Res
@@ -114,16 +130,16 @@ export const single = <Req extends Schema.Top, Res extends Schema.Top, E, R>(
   return (
     request: Req["Type"]
   ): Effect.Effect<
-    Res["Type"],
-    E | Schema.SchemaError | Cause.NoSuchElementError,
+    Option.Option<Res["Type"]>,
+    E | Schema.SchemaError,
     R | Req["EncodingServices"] | Res["DecodingServices"]
   > =>
     Effect.flatMap(
       Effect.flatMap(encodeRequest(request), options.execute),
       (arr): Effect.Effect<
-        Res["Type"],
-        Schema.SchemaError | Cause.NoSuchElementError,
+        Option.Option<Res["Type"]>,
+        Schema.SchemaError,
         Req["EncodingServices"] | Res["DecodingServices"]
-      > => Arr.isReadonlyArrayNonEmpty(arr) ? decode(arr[0]) : Effect.fail(new Cause.NoSuchElementError())
+      > => Arr.isReadonlyArrayNonEmpty(arr) ? Effect.asSome(decode(arr[0])) : Effect.succeedNone
     )
 }

package/src/unstable/sql/Statement.ts

@@ -2,16 +2,14 @@
  * @since 4.0.0
  */
 import { Clock } from "../../Clock.ts"
+import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
+import * as Effectable from "../../Effectable.ts"
 import type * as Fiber from "../../Fiber.ts"
 import { constUndefined } from "../../Function.ts"
-import type { Inspectable } from "../../Inspectable.ts"
-import * as core from "../../internal/core.ts"
 import * as internalEffect from "../../internal/effect.ts"
-import type { Pipeable } from "../../Pipeable.ts"
 import { hasProperty } from "../../Predicate.ts"
 import { TracerTimingEnabled } from "../../References.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as Stream from "../../Stream.ts"
 import type * as Tracer from "../../Tracer.ts"
 import type { Acquirer, Connection, Row } from "./SqlConnection.ts"
@@ -49,7 +47,7 @@ export type Dialect = "sqlite" | "pg" | "mysql" | "mssql" | "clickhouse"
  * @category model
  * @since 4.0.0
  */
-export interface Statement<A> extends Fragment, Effect.Effect<ReadonlyArray<A>, SqlError>, Pipeable, Inspectable {
+export interface Statement<A> extends Fragment, Effect.Effect<ReadonlyArray<A>, SqlError> {
   readonly raw: Effect.Effect<unknown, SqlError>
   readonly withoutTransform: Effect.Effect<ReadonlyArray<A>, SqlError>
   readonly stream: Stream.Stream<A, SqlError>
@@ -76,7 +74,7 @@ export type Transformer = (
  * @category transformer
  * @since 4.0.0
  */
-export const CurrentTransformer = ServiceMap.Reference<Transformer | undefined>("effect/sql/CurrentTransformer", {
+export const CurrentTransformer = Context.Reference<Transformer | undefined>("effect/sql/CurrentTransformer", {
   defaultValue: constUndefined
 })
 
@@ -1128,8 +1126,23 @@ const StatementProto: Omit<
   StatementImpl<any>,
   "segments" | "acquirer" | "compiler" | "spanAttributes" | "transformRows"
 > = {
-  ...core.EffectProto,
-  [core.identifier as any]: "Statement",
+  ...Effectable.Prototype<StatementImpl<any>>({
+    label: "Statement",
+    evaluate(fiber) {
+      const span = internalEffect.makeSpanUnsafe(fiber, "sql.execute", { kind: "client" })
+      const clock = fiber.getRef(Clock)
+      const timingEnabled = fiber.getRef(TracerTimingEnabled)
+      return Effect.onExit(
+        this.withConnectionSpan(
+          "execute",
+          (connection, sql, params) => connection.execute(sql, params, this.transformRows),
+          false,
+          span
+        ),
+        (exit) => internalEffect.endSpan(span, exit, clock, timingEnabled)
+      )
+    }
+  }),
   [FragmentTypeId]: FragmentTypeId,
   withConnection<XA, E>(
     this: StatementImpl<any>,
@@ -1229,23 +1242,6 @@ const StatementProto: Omit<
   ) {
     return this.compiler.compile(this, withoutTransform ?? false)
   },
-  [core.evaluate as any](
-    this: StatementImpl<any>,
-    fiber: Fiber.Fiber<any, any>
-  ): Effect.Effect<ReadonlyArray<any>, SqlError> {
-    const span = internalEffect.makeSpanUnsafe(fiber, "sql.execute", { kind: "client" })
-    const clock = fiber.getRef(Clock)
-    const timingEnabled = fiber.getRef(TracerTimingEnabled)
-    return Effect.onExit(
-      this.withConnectionSpan(
-        "execute",
-        (connection, sql, params) => connection.execute(sql, params, this.transformRows),
-        false,
-        span
-      ),
-      (exit) => internalEffect.endSpan(span, exit, clock, timingEnabled)
-    )
-  },
   toJSON(this: StatementImpl<any>) {
     const [sql, params] = this.compile()
     return {

package/src/unstable/workers/Transferable.ts

@@ -1,17 +1,17 @@
 /**
  * @since 1.0.0
  */
+import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import { dual } from "../../Function.ts"
 import * as Schema from "../../Schema.ts"
 import * as Getter from "../../SchemaGetter.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 
 /**
  * @since 1.0.0
  * @category models
  */
-export class Collector extends ServiceMap.Service<Collector, {
+export class Collector extends Context.Service<Collector, {
   readonly addAll: (
     _: Iterable<globalThis.Transferable>
   ) => Effect.Effect<void>
@@ -60,8 +60,8 @@ export const makeCollector: Effect.Effect<Collector["Service"]> = Effect.sync(ma
 export const addAll = (
   tranferables: Iterable<globalThis.Transferable>
 ): Effect.Effect<void> =>
-  Effect.servicesWith((services) => {
-    const collector = ServiceMap.getOrUndefined(services, Collector)
+  Effect.contextWith((services) => {
+    const collector = Context.getOrUndefined(services, Collector)
     if (!collector) return Effect.void
     collector.addAllUnsafe(tranferables)
     return Effect.void
@@ -75,8 +75,8 @@ export const getterAddAll = <A>(
   f: (_: A) => Iterable<globalThis.Transferable>
 ): Getter.Getter<A, A> =>
   Getter.transformOrFail((e: A) =>
-    Effect.servicesWith((services) => {
-      const collector = ServiceMap.getOrUndefined(services, Collector)
+    Effect.contextWith((services) => {
+      const collector = Context.getOrUndefined(services, Collector)
       if (!collector) return Effect.succeed(e)
       collector.addAllUnsafe(f(e))
       return Effect.succeed(e)
@@ -89,8 +89,8 @@ export const getterAddAll = <A>(
  */
 export interface Transferable<S extends Schema.Top> extends
   Schema.decodeTo<
-    Schema.toType<S["~rebuild.out"]>,
-    S["~rebuild.out"]
+    Schema.toType<S["Rebuild"]>,
+    S["Rebuild"]
   >
 {}
 
@@ -115,16 +115,14 @@ export const schema: {
     self: S,
     f: (_: S["Encoded"]) => Iterable<globalThis.Transferable>
   ): Transferable<S> =>
-    self
-      .annotate({
-        serializerJson: () => passthroughLink
+    self.annotate({
+      toCodecJson: () => passthroughLink
+    }).pipe(
+      Schema.decode({
+        decode: Getter.passthrough(),
+        encode: getterAddAll(f)
       })
-      .pipe(
-        Schema.decode({
-          decode: Getter.passthrough(),
-          encode: getterAddAll(f)
-        })
-      )
+    )
 )
 
 const passthroughLink = Schema.link()(Schema.Any, {
@@ -154,7 +152,7 @@ export const MessagePort: Transferable<Schema.declare<MessagePort>> = schema(
  * @since 1.0.0
  * @category schema
  */
-export const Uint8Array: Transferable<Schema.Uint8Array> = schema(
-  Schema.Uint8Array,
+export const Uint8Array: Transferable<Schema.instanceOf<globalThis.Uint8Array<ArrayBuffer>>> = schema(
+  Schema.Uint8Array as any,
   (_) => [_.buffer]
 )