effect-start 0.25.0 → 0.27.0

package/src/sql/bun/index.ts

@@ -4,7 +4,8 @@ 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 * as Sql from "../Sql.ts"
+import * as Sql from "../SqlClient.ts"
+import * as Values from "../../Values.ts"
 
 const errorCode = (error: unknown): string => {
   const e = error as any
@@ -22,20 +23,14 @@ const wrapError = (error: unknown): Sql.SqlError =>
 const wrap = <T>(fn: () => PromiseLike<T>): Effect.Effect<T, Sql.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 }
-}
-
-interface TxState {
+interface TransactionConnection {
   readonly conn: any
   readonly depth: number
 }
 
 const currentTransaction = GlobalValue.globalValue(
   Symbol.for("effect-start/sql/bun/currentTransaction"),
-  () => FiberRef.unsafeMake<Option.Option<TxState>>(Option.none()),
+  () => FiberRef.unsafeMake<Option.Option<TransactionConnection>>(Option.none()),
 )
 
 const makeRun =
@@ -45,6 +40,72 @@ const makeRun =
       wrap(() => fn(Option.isSome(txOpt) ? txOpt.value.conn : bunSql)),
     )
 
+const detectDialect = (bunSql: any): Sql.DialectConfig => {
+  const adapter = bunSql?.options?.adapter ?? bunSql?.adapter
+  if (adapter === "sqlite") return Sql.sqliteDialect
+  return Sql.postgresDialect
+}
+
+const makeSpanAttributes = (config: ConstructorParameters<typeof Bun.SQL>[0]): Record<string, unknown> => {
+  const c = config as Record<string, unknown>
+  const adapter = c.adapter
+  if (adapter === "sqlite") {
+    return Values.compact({
+      ...(c.spanAttributes as Record<string, unknown> | undefined),
+      "db.system.name": "sqlite",
+    })
+  }
+
+  const parsed = (() => {
+    if (typeof c.url !== "string") return undefined
+    try {
+      return new URL(c.url)
+    } catch {
+      return undefined
+    }
+  })()
+  const dbFromPath = parsed?.pathname.replace(/^\/+/, "") || undefined
+  const parsedPort = parsed?.port ? Number(parsed.port) : undefined
+
+  return Values.compact({
+    ...(c.spanAttributes as Record<string, unknown> | undefined),
+    "db.system.name": "postgresql",
+    "db.namespace": (c.database as string | undefined) ?? dbFromPath,
+    "server.address": ((c.hostname ?? c.host) as string | undefined) ?? parsed?.hostname,
+    "server.port": (c.port as number | undefined) ?? parsedPort,
+  })
+}
+
+const makeTaggedTemplate = (
+  run: <T>(fn: (conn: any) => PromiseLike<T>) => Effect.Effect<T, Sql.SqlError>,
+  dialect: Sql.DialectConfig,
+) => {
+  const unsafeFn = <T = any>(query: string, values?: Array<unknown>) =>
+    run<ReadonlyArray<T>>((conn) => conn.unsafe(query, values))
+
+  return <T = any>(
+    strings: TemplateStringsArray,
+    ...values: Array<unknown>
+  ): Effect.Effect<ReadonlyArray<T>, Sql.SqlError> => {
+    if (Sql.hasFragments(values)) {
+      const compiled = Sql.interpolate(dialect, strings, values)
+      return unsafeFn<T>(compiled.sql, compiled.parameters)
+    }
+    return run<ReadonlyArray<T>>((conn) => conn(strings, ...values))
+  }
+}
+
+const makeQuery = (
+  run: <T>(fn: (conn: any) => PromiseLike<T>) => Effect.Effect<T, Sql.SqlError>,
+  dialect: Sql.DialectConfig,
+  spanAttributes: ReadonlyArray<readonly [string, unknown]>,
+): Sql.Connection => {
+  const query = makeTaggedTemplate(run, dialect)
+  const unsafe: Sql.Connection["unsafe"] = <T = any>(query: string, values?: Array<unknown>) =>
+    run<ReadonlyArray<T>>((conn) => conn.unsafe(query, values))
+  return Sql.connection(query, unsafe, { spanAttributes, dialect })
+}
+
 const makeWithTransaction =
   (bunSql: any) =>
   <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, Sql.SqlError | E, R> =>
@@ -98,50 +159,56 @@ const makeWithTransaction =
     )
 
 export const layer = (
-  config: ConstructorParameters<typeof Bun.SQL>[0],
+  config: ConstructorParameters<typeof Bun.SQL>[0] & {
+    readonly spanAttributes?: Record<string, unknown>
+  },
 ): Layer.Layer<Sql.SqlClient, Sql.SqlError> =>
   Layer.scoped(
     Sql.SqlClient,
-    Effect.acquireRelease(
-      Effect.try({
-        try: () => {
-          const bunSql = new Bun.SQL(config as any)
-          const run = makeRun(bunSql)
-          const use: Sql.SqlClient["use"] = (fn) =>
-            Effect.tryPromise({ try: () => Promise.resolve(fn(bunSql)), catch: wrapError })
-          return Object.assign(
-            <T = any>(strings: TemplateStringsArray, ...values: Array<unknown>) =>
-              run<ReadonlyArray<T>>((conn) => conn(strings, ...values)),
-            {
-              unsafe: <T = any>(query: string, values?: Array<unknown>) =>
-                run<ReadonlyArray<T>>((conn) => conn.unsafe(query, values)),
-              values: makeValues,
-              withTransaction: makeWithTransaction(bunSql),
-              reserve: Effect.acquireRelease(
-                wrap(() => bunSql.reserve()),
-                (reserved: any) => Effect.sync(() => reserved.release()),
-              ).pipe(
-                Effect.map(
-                  (reserved: any): Sql.SqlQuery =>
-                    Object.assign(
-                      <T = any>(strings: TemplateStringsArray, ...values: Array<unknown>) =>
-                        wrap<ReadonlyArray<T>>(() => reserved(strings, ...values)),
-                      {
-                        unsafe: <T = any>(query: string, values?: Array<unknown>) =>
-                          wrap<ReadonlyArray<T>>(() => reserved.unsafe(query, values)),
-                        values: makeValues,
-                      },
-                    ),
+    Effect.map(
+      Effect.acquireRelease(
+        Effect.try({
+          try: () => {
+            const driverConfig = { ...config } as Record<string, unknown>
+            delete driverConfig.spanAttributes
+            const bunSql = new Bun.SQL(driverConfig as any)
+            const run = makeRun(bunSql)
+            const dialect = detectDialect(bunSql)
+            const spanAttributes = Object.entries(makeSpanAttributes(config))
+            const unsafeFn: Sql.Connection["unsafe"] = <T = any>(
+              query: string,
+              values?: Array<unknown>,
+            ) => run<ReadonlyArray<T>>((conn) => conn.unsafe(query, values))
+            const query = makeTaggedTemplate(run, dialect)
+            const use: Sql.SqlClient["use"] = (fn) =>
+              Effect.tryPromise({ try: () => Promise.resolve(fn(bunSql)), catch: wrapError })
+
+            return {
+              client: Sql.make({
+                query,
+                unsafe: unsafeFn,
+                withTransaction: makeWithTransaction(bunSql),
+                spanAttributes,
+                dialect,
+                reserve: Effect.acquireRelease(
+                  wrap(() => bunSql.reserve()),
+                  (reserved: any) => Effect.sync(() => reserved.release()),
+                ).pipe(
+                  Effect.map((reserved: any): Sql.Connection => {
+                    const reservedRun = <T>(fn: (conn: any) => PromiseLike<T>) =>
+                      wrap<T>(() => fn(reserved))
+                    return makeQuery(reservedRun, dialect, spanAttributes)
+                  }),
                 ),
-              ),
-              close: (options?: { readonly timeout?: number }) =>
-                use((bunSql) => bunSql.close(options)),
-              use,
-            },
-          ) satisfies Sql.SqlClient
-        },
-        catch: wrapError,
-      }),
-      (client) => client.close().pipe(Effect.orDie),
+                use,
+              }),
+              close: use((bunSql) => bunSql.close()),
+            }
+          },
+          catch: wrapError,
+        }),
+        (handle) => handle.close.pipe(Effect.orDie),
+      ),
+      (handle) => handle.client,
     ),
   )

package/src/sql/index.ts

@@ -1 +1 @@
-export * as Sql from "./Sql.ts"
+export * as SqlClient from "./SqlClient.ts"

package/src/sql/libsql/index.ts

@@ -5,7 +5,8 @@ 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 Sql from "../SqlClient.ts"
+import * as Values from "../../Values.ts"
 
 export interface LibsqlConfig {
   readonly url: string
@@ -13,6 +14,7 @@ export interface LibsqlConfig {
   readonly syncUrl?: string
   readonly syncInterval?: number
   readonly encryptionKey?: string
+  readonly spanAttributes?: Record<string, unknown>
 }
 
 const wrapError = (error: unknown): Sql.SqlError =>
@@ -25,12 +27,28 @@ const wrapError = (error: unknown): Sql.SqlError =>
 const wrap = <T>(fn: () => PromiseLike<T>): Effect.Effect<T, Sql.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 = Sql.sqliteDialect
+const makeSpanAttributes = (config: LibsqlConfig): 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 +58,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>, Sql.SqlError> =>
+  wrap(() => client.execute({ sql, args })).pipe(Effect.map(resultSetToRows<T>))
 
-interface TxState {
+interface TransactionConnection {
   readonly depth: number
 }
 
@@ -58,34 +77,39 @@ 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>, Sql.SqlError> => {
+    if (Sql.hasFragments(values)) {
+      const compiled = Sql.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]>,
+): Sql.Connection => {
+  const query = makeTaggedTemplate(client)
+  const unsafe: Sql.Connection["unsafe"] = <T = any>(query: string, values?: Array<unknown>) =>
+    executeQuery<T>(client, query, values ?? [])
+  return Sql.connection(query, unsafe, { spanAttributes, dialect })
+}
 
 const makeWithTransaction =
   (client: Libsql.Client) =>
@@ -98,9 +122,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}`)
@@ -129,45 +151,37 @@ const makeWithTransaction =
 export const layer = (config: LibsqlConfig): Layer.Layer<Sql.SqlClient, Sql.SqlError> =>
   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
-        }),
+    Effect.map(
+      Effect.acquireRelease(
+        wrap(() => loadLibsql()).pipe(
+          Effect.map((libsql) => {
+            const client = libsql.createClient(config)
+            const spanAttributes = makeSpanAttributes(config)
+            const query = makeTaggedTemplate(client)
+            const unsafeFn: Sql.Connection["unsafe"] = <T = any>(
+              query: string,
+              values?: Array<unknown>,
+            ) => executeQuery<T>(client, query, values ?? [])
+            const use: Sql.SqlClient["use"] = (fn) =>
+              Effect.tryPromise({ try: () => Promise.resolve(fn(client)), catch: wrapError })
+
+            return {
+              client: Sql.make({
+                query,
+                unsafe: unsafeFn,
+                withTransaction: makeWithTransaction(client),
+                spanAttributes,
+                dialect,
+                // libsql has no connection pool — reuse the existing client
+                reserve: Effect.succeed(makeQuery(client, spanAttributes)),
+                use,
+              }),
+              close: Effect.sync(() => client.close()),
+            }
+          }),
+        ),
+        (handle) => handle.close.pipe(Effect.orDie),
       ),
-      (client) => client.close().pipe(Effect.orDie),
+      (handle) => 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
   }