effect-start 0.27.0 → 0.28.0

package/src/sql/SqlClient.ts

@@ -21,6 +21,11 @@ export interface DialectConfig {
 
 export type SqlRow = Record<string, unknown>
 
+export type SqlEffect<A extends object = SqlRow> = Effect.Effect<ReadonlyArray<A>, SqlError> & {
+  readonly sql: string
+  readonly parameters: ReadonlyArray<unknown>
+}
+
 export interface Connection {
   /**
    * Execute a parameterized query via tagged template literal
@@ -28,7 +33,7 @@ export interface Connection {
   <A extends object = SqlRow>(
     strings: TemplateStringsArray,
     ...values: Array<unknown>
-  ): Effect.Effect<ReadonlyArray<A>, SqlError>
+  ): SqlEffect<A>
   /**
    * Create a safely-escaped SQL identifier from a string
    */
@@ -52,9 +57,14 @@ export interface Connection {
   readonly unsafe: <A extends object = SqlRow>(
     query: string,
     values?: Array<unknown>,
-  ) => Effect.Effect<ReadonlyArray<A>, SqlError>
+  ) => SqlEffect<A>
 }
 
+export type UnsafeQuery = <A extends object = SqlRow>(
+  query: string,
+  values?: Array<unknown>,
+) => Effect.Effect<ReadonlyArray<A>, SqlError>
+
 export interface SqlClient extends Connection {
   /**
    * Run an effect inside a transaction
@@ -87,7 +97,7 @@ export interface MakeOptions {
   readonly withTransaction: SqlClient["withTransaction"]
   readonly reserve: SqlClient["reserve"]
   readonly use: SqlClient["use"]
-  readonly unsafe: Connection["unsafe"]
+  readonly unsafe: UnsafeQuery
   readonly query: TaggedQuery
   readonly spanAttributes: ReadonlyArray<readonly [string, unknown]>
   readonly dialect: DialectConfig
@@ -95,10 +105,28 @@ export interface MakeOptions {
 
 export function make(options: MakeOptions): SqlClient {
   const trace = makeTraceOptions(options.spanAttributes, options.dialect)
-  const query = withExecuteSpan(options.query, trace)
-  const unsafe = withUnsafeExecuteSpan(options.unsafe, trace)
+  const baseQuery = withExecuteSpan(options.query, trace)
+  const baseUnsafe = withUnsafeExecuteSpan(options.unsafe, trace)
   const withTransaction = withTransactionSpan(options.withTransaction, trace.spanAttributes)
 
+  const query: TaggedQuery = <A extends object = SqlRow>(
+    strings: TemplateStringsArray,
+    ...values: Array<unknown>
+  ): SqlEffect<A> =>
+    Object.assign(baseQuery<A>(strings, ...values), {
+      sql: renderTemplateSql(trace.dialect, strings, values),
+      parameters: values,
+    }) as SqlEffect<A>
+
+  const unsafe: Connection["unsafe"] = <A extends object = SqlRow>(
+    queryStr: string,
+    values?: Array<unknown>,
+  ): SqlEffect<A> =>
+    Object.assign(baseUnsafe<A>(queryStr, values), {
+      sql: queryStr,
+      parameters: values ?? [],
+    }) as SqlEffect<A>
+
   return Object.assign(dispatchCallable(query), {
     ...options,
     query,
@@ -109,7 +137,7 @@ export function make(options: MakeOptions): SqlClient {
 
 export function connection(
   query: TaggedQuery,
-  unsafe: Connection["unsafe"],
+  unsafe: UnsafeQuery,
   options?: {
     readonly spanAttributes?: ReadonlyArray<readonly [string, unknown]>
     readonly dialect?: DialectConfig
@@ -118,7 +146,28 @@ export function connection(
   const trace = makeTraceOptions(options?.spanAttributes, options?.dialect)
   const tracedQuery = withExecuteSpan(query, trace)
   const tracedUnsafe = withUnsafeExecuteSpan(unsafe, trace)
-  return Object.assign(dispatchCallable(tracedQuery), { unsafe: tracedUnsafe }) as unknown as Connection
+
+  const wrappedQuery: TaggedQuery = <A extends object = SqlRow>(
+    strings: TemplateStringsArray,
+    ...values: Array<unknown>
+  ): SqlEffect<A> =>
+    Object.assign(tracedQuery<A>(strings, ...values), {
+      sql: renderTemplateSql(trace.dialect, strings, values),
+      parameters: values,
+    }) as SqlEffect<A>
+
+  const wrappedUnsafe: Connection["unsafe"] = <A extends object = SqlRow>(
+    query: string,
+    values?: Array<unknown>,
+  ): SqlEffect<A> =>
+    Object.assign(tracedUnsafe<A>(query, values), {
+      sql: query,
+      parameters: values ?? [],
+    }) as SqlEffect<A>
+
+  return Object.assign(dispatchCallable(wrappedQuery), {
+    unsafe: wrappedUnsafe,
+  }) as unknown as Connection
 }
 
 function dispatchCallable(query: TaggedQuery) {
@@ -260,11 +309,11 @@ const withExecuteSpan =
 
 const withUnsafeExecuteSpan =
   (
-    unsafe: Connection["unsafe"],
+    unsafe: UnsafeQuery,
     options: {
       readonly spanAttributes: Record<string, unknown>
     },
-  ): Connection["unsafe"] =>
+  ): UnsafeQuery =>
   <A extends object = SqlRow>(
     query: string,
     values?: Array<unknown>,
@@ -299,11 +348,7 @@ const withTransactionSpan =
           Effect.flatMap(
             Effect.exit(
               Effect.withParentSpan(
-                Effect.locally(
-                  withTransaction(self),
-                  currentTransactionDepth,
-                  depth + 1,
-                ),
+                Effect.locally(withTransaction(self), currentTransactionDepth, depth + 1),
                 span,
               ),
             ),

package/src/sql/bun/index.ts

@@ -4,7 +4,7 @@ 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 "../SqlClient.ts"
+import * as SqlClient from "../SqlClient.ts"
 import * as Values from "../../Values.ts"
 
 const errorCode = (error: unknown): string => {
@@ -13,14 +13,14 @@ const errorCode = (error: unknown): string => {
   return e?.code ?? "UNKNOWN"
 }
 
-const wrapError = (error: unknown): Sql.SqlError =>
-  new Sql.SqlError({
+const wrapError = (error: unknown): SqlClient.SqlError =>
+  new SqlClient.SqlError({
     code: errorCode(error),
     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 })
 
 interface TransactionConnection {
@@ -35,18 +35,20 @@ const currentTransaction = GlobalValue.globalValue(
 
 const makeRun =
   (bunSql: any) =>
-  <T>(fn: (conn: any) => PromiseLike<T>): Effect.Effect<T, Sql.SqlError> =>
+  <T>(fn: (conn: any) => PromiseLike<T>): Effect.Effect<T, SqlClient.SqlError> =>
     Effect.flatMap(FiberRef.get(currentTransaction), (txOpt) =>
       wrap(() => fn(Option.isSome(txOpt) ? txOpt.value.conn : bunSql)),
     )
 
-const detectDialect = (bunSql: any): Sql.DialectConfig => {
+const detectDialect = (bunSql: any): SqlClient.DialectConfig => {
   const adapter = bunSql?.options?.adapter ?? bunSql?.adapter
-  if (adapter === "sqlite") return Sql.sqliteDialect
-  return Sql.postgresDialect
+  if (adapter === "sqlite") return SqlClient.sqliteDialect
+  return SqlClient.postgresDialect
 }
 
-const makeSpanAttributes = (config: ConstructorParameters<typeof Bun.SQL>[0]): Record<string, unknown> => {
+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") {
@@ -77,8 +79,8 @@ const makeSpanAttributes = (config: ConstructorParameters<typeof Bun.SQL>[0]): R
 }
 
 const makeTaggedTemplate = (
-  run: <T>(fn: (conn: any) => PromiseLike<T>) => Effect.Effect<T, Sql.SqlError>,
-  dialect: Sql.DialectConfig,
+  run: <T>(fn: (conn: any) => PromiseLike<T>) => Effect.Effect<T, SqlClient.SqlError>,
+  dialect: SqlClient.DialectConfig,
 ) => {
   const unsafeFn = <T = any>(query: string, values?: Array<unknown>) =>
     run<ReadonlyArray<T>>((conn) => conn.unsafe(query, values))
@@ -86,9 +88,9 @@ const makeTaggedTemplate = (
   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)
+  ): Effect.Effect<ReadonlyArray<T>, SqlClient.SqlError> => {
+    if (SqlClient.hasFragments(values)) {
+      const compiled = SqlClient.interpolate(dialect, strings, values)
       return unsafeFn<T>(compiled.sql, compiled.parameters)
     }
     return run<ReadonlyArray<T>>((conn) => conn(strings, ...values))
@@ -96,19 +98,19 @@ const makeTaggedTemplate = (
 }
 
 const makeQuery = (
-  run: <T>(fn: (conn: any) => PromiseLike<T>) => Effect.Effect<T, Sql.SqlError>,
-  dialect: Sql.DialectConfig,
+  run: <T>(fn: (conn: any) => PromiseLike<T>) => Effect.Effect<T, SqlClient.SqlError>,
+  dialect: SqlClient.DialectConfig,
   spanAttributes: ReadonlyArray<readonly [string, unknown]>,
-): Sql.Connection => {
+): SqlClient.Connection => {
   const query = makeTaggedTemplate(run, dialect)
-  const unsafe: Sql.Connection["unsafe"] = <T = any>(query: string, values?: Array<unknown>) =>
+  const unsafe: SqlClient.UnsafeQuery = <T = any>(query: string, values?: Array<unknown>) =>
     run<ReadonlyArray<T>>((conn) => conn.unsafe(query, values))
-  return Sql.connection(query, unsafe, { spanAttributes, dialect })
+  return SqlClient.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> =>
+  <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)) {
@@ -162,9 +164,9 @@ export const layer = (
   config: ConstructorParameters<typeof Bun.SQL>[0] & {
     readonly spanAttributes?: Record<string, unknown>
   },
-): Layer.Layer<Sql.SqlClient, Sql.SqlError> =>
+): Layer.Layer<SqlClient.SqlClient, SqlClient.SqlError> =>
   Layer.scoped(
-    Sql.SqlClient,
+    SqlClient.SqlClient,
     Effect.map(
       Effect.acquireRelease(
         Effect.try({
@@ -175,16 +177,16 @@ export const layer = (
             const run = makeRun(bunSql)
             const dialect = detectDialect(bunSql)
             const spanAttributes = Object.entries(makeSpanAttributes(config))
-            const unsafeFn: Sql.Connection["unsafe"] = <T = any>(
+            const unsafeFn: SqlClient.UnsafeQuery = <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) =>
+            const use: SqlClient.SqlClient["use"] = (fn) =>
               Effect.tryPromise({ try: () => Promise.resolve(fn(bunSql)), catch: wrapError })
 
             return {
-              client: Sql.make({
+              client: SqlClient.make({
                 query,
                 unsafe: unsafeFn,
                 withTransaction: makeWithTransaction(bunSql),
@@ -194,7 +196,7 @@ export const layer = (
                   wrap(() => bunSql.reserve()),
                   (reserved: any) => Effect.sync(() => reserved.release()),
                 ).pipe(
-                  Effect.map((reserved: any): Sql.Connection => {
+                  Effect.map((reserved: any): SqlClient.Connection => {
                     const reservedRun = <T>(fn: (conn: any) => PromiseLike<T>) =>
                       wrap<T>(() => fn(reserved))
                     return makeQuery(reservedRun, dialect, spanAttributes)

package/src/sql/index.ts

@@ -1 +1,2 @@
+export * as SqlCache from "./SqlCache.ts"
 export * as SqlClient from "./SqlClient.ts"

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,10 +6,21 @@ 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 "../SqlClient.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
@@ -17,18 +29,25 @@ export interface LibsqlConfig {
   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 dialect = Sql.sqliteDialect
-const makeSpanAttributes = (config: LibsqlConfig): ReadonlyArray<readonly [string, unknown]> => {
+const dialect = SqlClient.sqliteDialect
+const makeSpanAttributes = (config: ResolvedConfig): ReadonlyArray<readonly [string, unknown]> => {
   const parsed = (() => {
     try {
       return new URL(config.url)
@@ -41,7 +60,7 @@ const makeSpanAttributes = (config: LibsqlConfig): ReadonlyArray<readonly [strin
 
   return Object.entries(
     Values.compact({
-      ...(config.spanAttributes ?? {}),
+      ...config.spanAttributes,
       "db.system.name": "sqlite",
       "db.namespace": dbFromPath,
       "server.address": parsed?.hostname,
@@ -62,7 +81,7 @@ const executeQuery = <T>(
   client: Libsql.Client,
   sql: string,
   args: Array<unknown>,
-): Effect.Effect<ReadonlyArray<T>, Sql.SqlError> =>
+): Effect.Effect<ReadonlyArray<T>, SqlClient.SqlError> =>
   wrap(() => client.execute({ sql, args })).pipe(Effect.map(resultSetToRows<T>))
 
 interface TransactionConnection {
@@ -89,9 +108,9 @@ const makeTaggedTemplate = (client: Libsql.Client) => {
   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)
+  ): Effect.Effect<ReadonlyArray<T>, SqlClient.SqlError> => {
+    if (SqlClient.hasFragments(values)) {
+      const compiled = SqlClient.interpolate(dialect, strings, values)
       return unsafeFn<T>(compiled.sql, compiled.parameters)
     }
 
@@ -104,16 +123,16 @@ const makeTaggedTemplate = (client: Libsql.Client) => {
 const makeQuery = (
   client: Libsql.Client,
   spanAttributes: ReadonlyArray<readonly [string, unknown]>,
-): Sql.Connection => {
+): SqlClient.Connection => {
   const query = makeTaggedTemplate(client)
-  const unsafe: Sql.Connection["unsafe"] = <T = any>(query: string, values?: Array<unknown>) =>
+  const unsafe: SqlClient.UnsafeQuery = <T = any>(query: string, values?: Array<unknown>) =>
     executeQuery<T>(client, query, values ?? [])
-  return Sql.connection(query, unsafe, { spanAttributes, dialect })
+  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)) {
@@ -148,31 +167,46 @@ const makeWithTransaction =
       }),
     )
 
-export const layer = (config: LibsqlConfig): Layer.Layer<Sql.SqlClient, Sql.SqlError> =>
+export const layer = (config?: LibsqlConfig) =>
   Layer.scoped(
-    Sql.SqlClient,
-    Effect.map(
-      Effect.acquireRelease(
+    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(config)
-            const spanAttributes = makeSpanAttributes(config)
+            const client = libsql.createClient(resolved)
+            const spanAttributes = makeSpanAttributes(resolved)
             const query = makeTaggedTemplate(client)
-            const unsafeFn: Sql.Connection["unsafe"] = <T = any>(
+            const unsafeFn: SqlClient.UnsafeQuery = <T = any>(
               query: string,
               values?: Array<unknown>,
             ) => executeQuery<T>(client, query, values ?? [])
-            const use: Sql.SqlClient["use"] = (fn) =>
+            const use: SqlClient.SqlClient["use"] = (fn) =>
               Effect.tryPromise({ try: () => Promise.resolve(fn(client)), catch: wrapError })
 
             return {
-              client: Sql.make({
+              client: SqlClient.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,
               }),
@@ -181,7 +215,7 @@ export const layer = (config: LibsqlConfig): Layer.Layer<Sql.SqlClient, Sql.SqlE
           }),
         ),
         (handle) => handle.close.pipe(Effect.orDie),
-      ),
-      (handle) => handle.client,
-    ),
+      )
+      return handle.client
+    }),
   )