effect-start 0.26.0 → 0.28.0

package/src/sql/libsql/index.ts

@@ -1,3 +1,4 @@
+import * as Config from "effect/Config"
 import * as Effect from "effect/Effect"
 import * as Exit from "effect/Exit"
 import * as FiberRef from "effect/FiberRef"
@@ -5,32 +6,68 @@ import * as GlobalValue from "effect/GlobalValue"
 import * as Layer from "effect/Layer"
 import * as Option from "effect/Option"
 import type * as Libsql from "@libsql/client"
-import * as Sql from "../Sql.ts"
+import * as SqlClient from "../SqlClient.ts"
+import * as Values from "../../Values.ts"
+
+type ConfigOrValue<T> = T | Config.Config<T>
 
 export interface LibsqlConfig {
+  readonly url?: ConfigOrValue<string>
+  readonly authToken?: ConfigOrValue<string>
+  readonly syncUrl?: ConfigOrValue<string>
+  readonly syncInterval?: ConfigOrValue<number>
+  readonly encryptionKey?: ConfigOrValue<string>
+  readonly spanAttributes?: Record<string, unknown>
+}
+
+interface ResolvedConfig {
   readonly url: string
   readonly authToken?: string
   readonly syncUrl?: string
   readonly syncInterval?: number
   readonly encryptionKey?: string
+  readonly spanAttributes?: Record<string, unknown>
 }
 
-const wrapError = (error: unknown): Sql.SqlError =>
-  new Sql.SqlError({
+const resolveField = <T>(value: ConfigOrValue<T> | undefined) =>
+  value === undefined
+    ? Effect.succeed(undefined as T | undefined)
+    : Config.isConfig(value)
+      ? Effect.map(value, (v): T | undefined => v)
+      : Effect.succeed(value as T | undefined)
+
+const wrapError = (error: unknown): SqlClient.SqlError =>
+  new SqlClient.SqlError({
     code: (error as any)?.code ?? "UNKNOWN",
     message: error instanceof Error ? error.message : String(error),
     cause: error,
   })
 
-const wrap = <T>(fn: () => PromiseLike<T>): Effect.Effect<T, Sql.SqlError> =>
+const wrap = <T>(fn: () => PromiseLike<T>): Effect.Effect<T, SqlClient.SqlError> =>
   Effect.tryPromise({ try: () => Promise.resolve(fn()), catch: wrapError })
 
-const makeValues: Sql.SqlQuery["values"] = (obj: any, ...columns: Array<string>) => {
-  const items = Array.isArray(obj) ? obj : [obj]
-  const cols = columns.length > 0 ? columns : Object.keys(items[0])
-  return { value: items, columns: cols }
+const dialect = SqlClient.sqliteDialect
+const makeSpanAttributes = (config: ResolvedConfig): ReadonlyArray<readonly [string, unknown]> => {
+  const parsed = (() => {
+    try {
+      return new URL(config.url)
+    } catch {
+      return undefined
+    }
+  })()
+  const dbFromPath = parsed?.pathname.replace(/^\/+/, "") || undefined
+  const parsedPort = parsed?.port ? Number(parsed.port) : undefined
+
+  return Object.entries(
+    Values.compact({
+      ...config.spanAttributes,
+      "db.system.name": "sqlite",
+      "db.namespace": dbFromPath,
+      "server.address": parsed?.hostname,
+      "server.port": parsedPort,
+    }),
+  )
 }
-
 const resultSetToRows = <T>(result: Libsql.ResultSet): ReadonlyArray<T> => {
   const { columns, rows } = result
   return rows.map((row) => {
@@ -40,13 +77,14 @@ const resultSetToRows = <T>(result: Libsql.ResultSet): ReadonlyArray<T> => {
   })
 }
 
-const buildQuery = (strings: TemplateStringsArray, values: Array<unknown>) => {
-  let sql = strings[0]
-  for (let i = 0; i < values.length; i++) sql += "?" + strings[i + 1]
-  return { sql, args: values }
-}
+const executeQuery = <T>(
+  client: Libsql.Client,
+  sql: string,
+  args: Array<unknown>,
+): Effect.Effect<ReadonlyArray<T>, SqlClient.SqlError> =>
+  wrap(() => client.execute({ sql, args })).pipe(Effect.map(resultSetToRows<T>))
 
-interface TxState {
+interface TransactionConnection {
   readonly depth: number
 }
 
@@ -58,38 +96,43 @@ const loadLibsql = () => import("@libsql/client") as Promise<LibsqlModule>
 
 const currentTransaction = GlobalValue.globalValue(
   Symbol.for("effect-start/sql/libsql/currentTransaction"),
-  () => FiberRef.unsafeMake<Option.Option<TxState>>(Option.none()),
+  () => FiberRef.unsafeMake<Option.Option<TransactionConnection>>(Option.none()),
 )
 
-const executeQuery = <T>(
-  client: Libsql.Client,
-  sql: string,
-  args: Array<unknown>,
-): Effect.Effect<ReadonlyArray<T>, Sql.SqlError> =>
-  wrap(() => client.execute({ sql, args })).pipe(Effect.map(resultSetToRows<T>))
-
-const runQuery = <T>(
-  client: Libsql.Client,
-  strings: TemplateStringsArray,
-  values: Array<unknown>,
-): Effect.Effect<ReadonlyArray<T>, Sql.SqlError> => {
-  const { sql, args } = buildQuery(strings, values)
-  return executeQuery(client, sql, args)
+const exec = (client: Libsql.Client, sql: string) => wrap(() => client.execute(sql))
+
+const makeTaggedTemplate = (client: Libsql.Client) => {
+  const unsafeFn = <T = any>(query: string, values?: Array<unknown>) =>
+    executeQuery<T>(client, query, values ?? [])
+
+  return <T = any>(
+    strings: TemplateStringsArray,
+    ...values: Array<unknown>
+  ): Effect.Effect<ReadonlyArray<T>, SqlClient.SqlError> => {
+    if (SqlClient.hasFragments(values)) {
+      const compiled = SqlClient.interpolate(dialect, strings, values)
+      return unsafeFn<T>(compiled.sql, compiled.parameters)
+    }
+
+    let sqlText = strings[0]
+    for (let i = 0; i < values.length; i++) sqlText += "?" + strings[i + 1]
+    return executeQuery<T>(client, sqlText, values)
+  }
 }
 
-const runUnsafe = <T>(
+const makeQuery = (
   client: Libsql.Client,
-  query: string,
-  values?: Array<unknown>,
-): Effect.Effect<ReadonlyArray<T>, Sql.SqlError> =>
-  executeQuery(client, query, values ?? [])
-
-const exec = (client: Libsql.Client, sql: string) =>
-  wrap(() => client.execute(sql))
+  spanAttributes: ReadonlyArray<readonly [string, unknown]>,
+): SqlClient.Connection => {
+  const query = makeTaggedTemplate(client)
+  const unsafe: SqlClient.UnsafeQuery = <T = any>(query: string, values?: Array<unknown>) =>
+    executeQuery<T>(client, query, values ?? [])
+  return SqlClient.connection(query, unsafe, { spanAttributes, dialect })
+}
 
 const makeWithTransaction =
   (client: Libsql.Client) =>
-  <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, Sql.SqlError | E, R> =>
+  <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, SqlClient.SqlError | E, R> =>
     Effect.uninterruptibleMask((restore) =>
       Effect.flatMap(FiberRef.get(currentTransaction), (txOpt) => {
         if (Option.isSome(txOpt)) {
@@ -98,9 +141,7 @@ const makeWithTransaction =
           return Effect.gen(function* () {
             yield* exec(client, `SAVEPOINT ${name}`)
             const exit = yield* Effect.exit(
-              restore(
-                Effect.locally(self, currentTransaction, Option.some({ depth: depth + 1 })),
-              ),
+              restore(Effect.locally(self, currentTransaction, Option.some({ depth: depth + 1 }))),
             )
             if (Exit.isSuccess(exit)) {
               yield* exec(client, `RELEASE SAVEPOINT ${name}`)
@@ -126,48 +167,55 @@ const makeWithTransaction =
       }),
     )
 
-export const layer = (config: LibsqlConfig): Layer.Layer<Sql.SqlClient, Sql.SqlError> =>
+export const layer = (config?: LibsqlConfig) =>
   Layer.scoped(
-    Sql.SqlClient,
-    Effect.acquireRelease(
-      wrap(() => loadLibsql()).pipe(
-        Effect.map((libsql) => {
-          const client = libsql.createClient(config)
-          const use: Sql.SqlClient["use"] = (fn) =>
-            Effect.tryPromise({ try: () => Promise.resolve(fn(client)), catch: wrapError })
-          return Object.assign(
-            <T = any>(strings: TemplateStringsArray, ...values: Array<unknown>) =>
-              runQuery<T>(client, strings, values),
-            {
-              unsafe: <T = any>(query: string, values?: Array<unknown>) =>
-                runUnsafe<T>(client, query, values),
-              values: makeValues,
-              withTransaction: makeWithTransaction(client),
-              reserve: Effect.acquireRelease(
-                wrap(() => loadLibsql()).pipe(
-                  Effect.map((m) => m.createClient(config)),
-                ),
-                (reserved: Libsql.Client) => Effect.sync(() => reserved.close()),
-              ).pipe(
-                Effect.map(
-                  (reserved): Sql.SqlQuery =>
-                    Object.assign(
-                      <T = any>(strings: TemplateStringsArray, ...values: Array<unknown>) =>
-                        runQuery<T>(reserved, strings, values),
-                      {
-                        unsafe: <T = any>(query: string, values?: Array<unknown>) =>
-                          runUnsafe<T>(reserved, query, values),
-                        values: makeValues,
-                      },
-                    ),
-                ),
-              ),
-              close: () => Effect.sync(() => client.close()),
-              use,
-            },
-          ) satisfies Sql.SqlClient
-        }),
-      ),
-      (client) => client.close().pipe(Effect.orDie),
-    ),
+    SqlClient.SqlClient,
+    Effect.gen(function* () {
+      const envUrl = Option.getOrUndefined(
+        yield* Config.option(Config.string("TURSO_DATABASE_URL")),
+      )
+      const envAuthToken = Option.getOrUndefined(
+        yield* Config.option(Config.string("TURSO_AUTH_TOKEN")),
+      )
+      const configUrl = yield* resolveField(config?.url)
+      const configAuthToken = yield* resolveField(config?.authToken)
+      const resolved: ResolvedConfig = {
+        url: configUrl ?? envUrl ?? ":memory:",
+        authToken: configAuthToken ?? envAuthToken,
+        syncUrl: yield* resolveField(config?.syncUrl),
+        syncInterval: yield* resolveField(config?.syncInterval),
+        encryptionKey: yield* resolveField(config?.encryptionKey),
+        spanAttributes: config?.spanAttributes,
+      }
+      const handle = yield* Effect.acquireRelease(
+        wrap(() => loadLibsql()).pipe(
+          Effect.map((libsql) => {
+            const client = libsql.createClient(resolved)
+            const spanAttributes = makeSpanAttributes(resolved)
+            const query = makeTaggedTemplate(client)
+            const unsafeFn: SqlClient.UnsafeQuery = <T = any>(
+              query: string,
+              values?: Array<unknown>,
+            ) => executeQuery<T>(client, query, values ?? [])
+            const use: SqlClient.SqlClient["use"] = (fn) =>
+              Effect.tryPromise({ try: () => Promise.resolve(fn(client)), catch: wrapError })
+
+            return {
+              client: SqlClient.make({
+                query,
+                unsafe: unsafeFn,
+                withTransaction: makeWithTransaction(client),
+                spanAttributes,
+                dialect,
+                reserve: Effect.succeed(makeQuery(client, spanAttributes)),
+                use,
+              }),
+              close: Effect.sync(() => client.close()),
+            }
+          }),
+        ),
+        (handle) => handle.close.pipe(Effect.orDie),
+      )
+      return handle.client
+    }),
   )

package/src/sql/libsql/libsql.d.ts

@@ -21,7 +21,10 @@ declare module "@libsql/client" {
 
   export interface Client {
     execute(stmt: InStatement | string): Promise<ResultSet>
-    batch(stmts: ReadonlyArray<InStatement | string>, mode?: TransactionMode): Promise<ReadonlyArray<ResultSet>>
+    batch(
+      stmts: ReadonlyArray<InStatement | string>,
+      mode?: TransactionMode,
+    ): Promise<ReadonlyArray<ResultSet>>
     transaction(mode?: TransactionMode): Promise<Transaction>
     close(): void
   }

package/src/sql/mssql/index.ts

@@ -4,30 +4,12 @@ import * as FiberRef from "effect/FiberRef"
 import * as GlobalValue from "effect/GlobalValue"
 import * as Layer from "effect/Layer"
 import * as Option from "effect/Option"
-import type * as Mssql from "mssql"
-import * as Sql from "../Sql.ts"
-
-export interface MssqlConfig {
-  readonly server: string
-  readonly database?: string
-  readonly user?: string
-  readonly password?: string
-  readonly port?: number
-  readonly pool?: {
-    readonly max?: number
-    readonly min?: number
-    readonly idleTimeoutMillis?: number
-  }
-  readonly options?: {
-    readonly encrypt?: boolean
-    readonly trustServerCertificate?: boolean
-    readonly requestTimeout?: number
-    readonly connectionTimeout?: number
-  }
-}
+import * as Mssql from "mssql"
+import * as SqlClient from "../SqlClient.ts"
+import * as Values from "../../Values.ts"
 
-const wrapError = (error: unknown): Sql.SqlError =>
-  new Sql.SqlError({
+const wrapError = (error: unknown): SqlClient.SqlError =>
+  new SqlClient.SqlError({
     code:
       (error as any)?.code ??
       ((error as any)?.number != null ? String((error as any).number) : "UNKNOWN"),
@@ -35,16 +17,31 @@ const wrapError = (error: unknown): Sql.SqlError =>
     cause: error,
   })
 
-const makeValues: Sql.SqlQuery["values"] = (obj: any, ...columns: Array<string>) => {
-  const items = Array.isArray(obj) ? obj : [obj]
-  const cols = columns.length > 0 ? columns : Object.keys(items[0])
-  return { value: items, columns: cols }
-}
+const dialect = SqlClient.mssqlDialect
+const makeSpanAttributes = (
+  config: Mssql.config & {
+    readonly url?: string
+    readonly spanAttributes?: Record<string, unknown>
+  },
+): Record<string, unknown> => {
+  const parsed = (() => {
+    if (typeof config.url !== "string") return undefined
+    try {
+      return new URL(config.url)
+    } catch {
+      return undefined
+    }
+  })()
+  const dbFromPath = parsed?.pathname.replace(/^\/+/, "") || undefined
+  const parsedPort = parsed?.port ? Number(parsed.port) : undefined
 
-const buildQuery = (strings: TemplateStringsArray, values: Array<unknown>) => {
-  let text = strings[0]
-  for (let i = 0; i < values.length; i++) text += `@p${i + 1}` + strings[i + 1]
-  return { text, values }
+  return Values.compact({
+    ...config.spanAttributes,
+    "db.system.name": "microsoft.sql_server",
+    "db.namespace": config.database ?? dbFromPath,
+    "server.address": config.server ?? parsed?.hostname,
+    "server.port": config.port ?? parsedPort,
+  })
 }
 
 const addInputs = (request: Mssql.Request, values: Array<unknown>) => {
@@ -53,62 +50,82 @@ const addInputs = (request: Mssql.Request, values: Array<unknown>) => {
   }
 }
 
-interface TxState {
+interface TransactionConnection {
   readonly transaction: Mssql.Transaction
   readonly depth: number
 }
 
-type MssqlModule = {
-  ConnectionPool: new (config: Mssql.config) => Mssql.ConnectionPool
-}
-
-const loadMssql = () => import("mssql") as Promise<MssqlModule>
-
 const currentTransaction = GlobalValue.globalValue(
   Symbol.for("effect-start/sql/mssql/currentTransaction"),
-  () => FiberRef.unsafeMake<Option.Option<TxState>>(Option.none()),
+  () => FiberRef.unsafeMake<Option.Option<TransactionConnection>>(Option.none()),
 )
 
-const executeQuery = <T>(
+const makeRequest = (
   pool: Mssql.ConnectionPool,
-  text: string,
+  txOpt: Option.Option<TransactionConnection>,
   values: Array<unknown>,
-): Effect.Effect<ReadonlyArray<T>, Sql.SqlError> =>
-  Effect.flatMap(FiberRef.get(currentTransaction), (txOpt) => {
-    const request = Option.isSome(txOpt) ? txOpt.value.transaction.request() : pool.request()
-    addInputs(request, values)
-    return Effect.tryPromise({
-      try: () => request.query<T>(text),
-      catch: wrapError,
-    }).pipe(Effect.map((result) => result.recordset ?? []))
-  })
+): Mssql.Request => {
+  const request = Option.isSome(txOpt) ? txOpt.value.transaction.request() : pool.request()
+  addInputs(request, values)
+  return request
+}
 
-const runQuery = <T>(
+const executeQuery = <T>(
   pool: Mssql.ConnectionPool,
-  strings: TemplateStringsArray,
+  text: string,
   values: Array<unknown>,
-): Effect.Effect<ReadonlyArray<T>, Sql.SqlError> => {
-  const { text, values: params } = buildQuery(strings, values)
-  return executeQuery(pool, text, params)
-}
+): Effect.Effect<ReadonlyArray<T>, SqlClient.SqlError> =>
+  Effect.flatMap(FiberRef.get(currentTransaction), (txOpt) =>
+    Effect.tryPromise({
+      try: () => makeRequest(pool, txOpt, values).query<T>(text),
+      catch: wrapError,
+    }).pipe(Effect.map((result) => result.recordset ?? [])),
+  )
 
 const runUnsafe = <T>(
   pool: Mssql.ConnectionPool,
   query: string,
   values?: Array<unknown>,
-): Effect.Effect<ReadonlyArray<T>, Sql.SqlError> =>
-  Effect.flatMap(FiberRef.get(currentTransaction), (txOpt) => {
-    const request = Option.isSome(txOpt) ? txOpt.value.transaction.request() : pool.request()
-    if (values) addInputs(request, values)
-    return Effect.tryPromise({
-      try: () => request.query<T>(query),
+): Effect.Effect<ReadonlyArray<T>, SqlClient.SqlError> =>
+  Effect.flatMap(FiberRef.get(currentTransaction), (txOpt) =>
+    Effect.tryPromise({
+      try: () => makeRequest(pool, txOpt, values ?? []).query<T>(query),
       catch: wrapError,
-    }).pipe(Effect.map((result) => result.recordset ?? []))
-  })
+    }).pipe(Effect.map((result) => result.recordset ?? [])),
+  )
+
+const makeTaggedTemplate = (pool: Mssql.ConnectionPool) => {
+  const unsafeFn = <T = any>(query: string, values?: Array<unknown>) =>
+    runUnsafe<T>(pool, query, values)
+
+  return <T = any>(
+    strings: TemplateStringsArray,
+    ...values: Array<unknown>
+  ): Effect.Effect<ReadonlyArray<T>, SqlClient.SqlError> => {
+    if (SqlClient.hasFragments(values)) {
+      const compiled = SqlClient.interpolate(dialect, strings, values)
+      return unsafeFn<T>(compiled.sql, compiled.parameters)
+    }
+
+    let text = strings[0]
+    for (let i = 0; i < values.length; i++) text += `@p${i + 1}` + strings[i + 1]
+    return executeQuery<T>(pool, text, values)
+  }
+}
+
+const makeQuery = (
+  pool: Mssql.ConnectionPool,
+  spanAttributes: ReadonlyArray<readonly [string, unknown]>,
+): SqlClient.Connection => {
+  const query = makeTaggedTemplate(pool)
+  const unsafe: SqlClient.UnsafeQuery = <T = any>(query: string, values?: Array<unknown>) =>
+    runUnsafe<T>(pool, query, values)
+  return SqlClient.connection(query, unsafe, { spanAttributes, dialect })
+}
 
 const makeWithTransaction =
   (pool: Mssql.ConnectionPool) =>
-  <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, Sql.SqlError | E, R> =>
+  <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, SqlClient.SqlError | E, R> =>
     Effect.uninterruptibleMask((restore) =>
       Effect.flatMap(FiberRef.get(currentTransaction), (txOpt) => {
         if (Option.isSome(txOpt)) {
@@ -161,63 +178,75 @@ const makeWithTransaction =
       }),
     )
 
-export const layer = (config: MssqlConfig): Layer.Layer<Sql.SqlClient, Sql.SqlError> =>
+export const layer = (
+  config: Mssql.config & {
+    readonly url?: string
+    readonly spanAttributes?: Record<string, unknown>
+  },
+): Layer.Layer<SqlClient.SqlClient, SqlClient.SqlError> =>
   Layer.scoped(
-    Sql.SqlClient,
-    Effect.acquireRelease(
-      Effect.tryPromise({
-        try: async () => {
-          const mssql = await loadMssql()
-          const pool = await new mssql.ConnectionPool(config as Mssql.config).connect()
-          return { mssql, pool }
-        },
-        catch: wrapError,
-      }).pipe(
-        Effect.map(({ mssql, pool }) => {
-          const use: Sql.SqlClient["use"] = (fn) =>
-            Effect.tryPromise({ try: () => Promise.resolve(fn(pool)), catch: wrapError })
-          return Object.assign(
-            <T = any>(strings: TemplateStringsArray, ...values: Array<unknown>) =>
-              runQuery<T>(pool, strings, values),
-            {
-              unsafe: <T = any>(query: string, values?: Array<unknown>) =>
-                runUnsafe<T>(pool, query, values),
-              values: makeValues,
-              withTransaction: makeWithTransaction(pool),
-              reserve: Effect.acquireRelease(
-                Effect.tryPromise({
-                  try: () =>
-                    new mssql.ConnectionPool({
-                      ...config,
-                      pool: { max: 1, min: 1 },
-                    } as Mssql.config).connect(),
-                  catch: wrapError,
-                }),
-                (reserved: Mssql.ConnectionPool) =>
-                  Effect.tryPromise({ try: () => reserved.close(), catch: () => void 0 }).pipe(
-                    Effect.asVoid,
-                    Effect.orDie,
-                  ),
-              ).pipe(
-                Effect.map(
-                  (reserved): Sql.SqlQuery =>
-                    Object.assign(
-                      <T = any>(strings: TemplateStringsArray, ...values: Array<unknown>) =>
-                        runQuery<T>(reserved, strings, values),
-                      {
-                        unsafe: <T = any>(query: string, values?: Array<unknown>) =>
-                          runUnsafe<T>(reserved, query, values),
-                        values: makeValues,
-                      },
+    SqlClient.SqlClient,
+    Effect.map(
+      Effect.acquireRelease(
+        Effect.tryPromise({
+          try: async () => {
+            const driverConfig = { ...config } as Record<string, unknown>
+            delete driverConfig.spanAttributes
+            delete driverConfig.url
+            const pool = await new Mssql.ConnectionPool(
+              driverConfig as unknown as Mssql.config,
+            ).connect()
+            return pool
+          },
+          catch: wrapError,
+        }).pipe(
+          Effect.map((pool) => {
+            const driverConfig = { ...config } as Record<string, unknown>
+            delete driverConfig.spanAttributes
+            delete driverConfig.url
+            const spanAttributes = Object.entries(makeSpanAttributes(config))
+            const query = makeTaggedTemplate(pool)
+            const unsafeFn: SqlClient.UnsafeQuery = <T = any>(
+              query: string,
+              values?: Array<unknown>,
+            ) => runUnsafe<T>(pool, query, values)
+            const use: SqlClient.SqlClient["use"] = (fn) =>
+              Effect.tryPromise({ try: () => Promise.resolve(fn(pool)), catch: wrapError })
+
+            return {
+              client: SqlClient.make({
+                query,
+                unsafe: unsafeFn,
+                withTransaction: makeWithTransaction(pool),
+                spanAttributes,
+                dialect,
+                reserve: Effect.acquireRelease(
+                  Effect.tryPromise({
+                    try: () =>
+                      new Mssql.ConnectionPool({
+                        ...driverConfig,
+                        pool: { max: 1, min: 1 },
+                      } as unknown as Mssql.config).connect(),
+                    catch: wrapError,
+                  }),
+                  (reserved: Mssql.ConnectionPool) =>
+                    Effect.tryPromise({ try: () => reserved.close(), catch: () => void 0 }).pipe(
+                      Effect.asVoid,
+                      Effect.orDie,
                     ),
+                ).pipe(
+                  Effect.map(
+                    (reserved): SqlClient.Connection => makeQuery(reserved, spanAttributes),
+                  ),
                 ),
-              ),
-              close: () => use((pool) => pool.close()),
-              use,
-            },
-          ) satisfies Sql.SqlClient
-        }),
+                use,
+              }),
+              close: use((p) => p.close()),
+            }
+          }),
+        ),
+        (handle) => handle.close.pipe(Effect.orDie),
       ),
-      (client) => client.close().pipe(Effect.orDie),
+      (handle) => handle.client,
     ),
   )

package/src/sql/mssql/mssql.d.ts

@@ -1,3 +1,4 @@
+// types from @types/mssql@9.1.9
 declare module "mssql" {
   export interface config {
     readonly server: string