effect-start 0.27.0 → 0.28.0

package/src/sql/mssql/index.ts

@@ -4,12 +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 "../SqlClient.ts"
+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"),
@@ -17,33 +17,32 @@ const wrapError = (error: unknown): Sql.SqlError =>
     cause: error,
   })
 
-const dialect = Sql.mssqlDialect
+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
-
-    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,
-    })
-  }
+): 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
+
+  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>) => {
   for (let i = 0; i < values.length; i++) {
@@ -56,12 +55,6 @@ interface TransactionConnection {
   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<TransactionConnection>>(Option.none()),
@@ -81,7 +74,7 @@ const executeQuery = <T>(
   pool: Mssql.ConnectionPool,
   text: string,
   values: Array<unknown>,
-): Effect.Effect<ReadonlyArray<T>, Sql.SqlError> =>
+): Effect.Effect<ReadonlyArray<T>, SqlClient.SqlError> =>
   Effect.flatMap(FiberRef.get(currentTransaction), (txOpt) =>
     Effect.tryPromise({
       try: () => makeRequest(pool, txOpt, values).query<T>(text),
@@ -93,7 +86,7 @@ const runUnsafe = <T>(
   pool: Mssql.ConnectionPool,
   query: string,
   values?: Array<unknown>,
-): Effect.Effect<ReadonlyArray<T>, Sql.SqlError> =>
+): Effect.Effect<ReadonlyArray<T>, SqlClient.SqlError> =>
   Effect.flatMap(FiberRef.get(currentTransaction), (txOpt) =>
     Effect.tryPromise({
       try: () => makeRequest(pool, txOpt, values ?? []).query<T>(query),
@@ -108,9 +101,9 @@ const makeTaggedTemplate = (pool: Mssql.ConnectionPool) => {
   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)
     }
 
@@ -123,16 +116,16 @@ const makeTaggedTemplate = (pool: Mssql.ConnectionPool) => {
 const makeQuery = (
   pool: Mssql.ConnectionPool,
   spanAttributes: ReadonlyArray<readonly [string, unknown]>,
-): Sql.Connection => {
+): SqlClient.Connection => {
   const query = makeTaggedTemplate(pool)
-  const unsafe: Sql.Connection["unsafe"] = <T = any>(query: string, values?: Array<unknown>) =>
+  const unsafe: SqlClient.UnsafeQuery = <T = any>(query: string, values?: Array<unknown>) =>
     runUnsafe<T>(pool, query, values)
-  return Sql.connection(query, unsafe, { spanAttributes, dialect })
+  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)) {
@@ -190,46 +183,47 @@ export const layer = (
     readonly url?: string
     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.tryPromise({
           try: async () => {
-            const mssql = await loadMssql()
             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 { mssql, pool }
+            const pool = await new Mssql.ConnectionPool(
+              driverConfig as unknown as Mssql.config,
+            ).connect()
+            return pool
           },
           catch: wrapError,
         }).pipe(
-          Effect.map((options) => {
+          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(options.pool)
-            const unsafeFn: Sql.Connection["unsafe"] = <T = any>(
+            const query = makeTaggedTemplate(pool)
+            const unsafeFn: SqlClient.UnsafeQuery = <T = any>(
               query: string,
               values?: Array<unknown>,
-            ) => runUnsafe<T>(options.pool, query, values)
-            const use: Sql.SqlClient["use"] = (fn) =>
-              Effect.tryPromise({ try: () => Promise.resolve(fn(options.pool)), catch: wrapError })
+            ) => runUnsafe<T>(pool, query, values)
+            const use: SqlClient.SqlClient["use"] = (fn) =>
+              Effect.tryPromise({ try: () => Promise.resolve(fn(pool)), catch: wrapError })
 
             return {
-              client: Sql.make({
+              client: SqlClient.make({
                 query,
                 unsafe: unsafeFn,
-                withTransaction: makeWithTransaction(options.pool),
+                withTransaction: makeWithTransaction(pool),
                 spanAttributes,
                 dialect,
                 reserve: Effect.acquireRelease(
                   Effect.tryPromise({
                     try: () =>
-                      new options.mssql.ConnectionPool({
+                      new Mssql.ConnectionPool({
                         ...driverConfig,
                         pool: { max: 1, min: 1 },
                       } as unknown as Mssql.config).connect(),
@@ -241,11 +235,13 @@ export const layer = (
                       Effect.orDie,
                     ),
                 ).pipe(
-                  Effect.map((reserved): Sql.Connection => makeQuery(reserved, spanAttributes)),
+                  Effect.map(
+                    (reserved): SqlClient.Connection => makeQuery(reserved, spanAttributes),
+                  ),
                 ),
                 use,
               }),
-              close: use((pool) => pool.close()),
+              close: use((p) => p.close()),
             }
           }),
         ),

package/src/sql/postgres/index.ts

@@ -0,0 +1,254 @@
+import postgres from "postgres"
+import type * as Postgres from "postgres"
+import * as Effect from "effect/Effect"
+import * as Exit from "effect/Exit"
+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 SqlClient from "../SqlClient.ts"
+
+type PgConfig = string | Postgres.Options<Record<string, Postgres.PostgresType>>
+
+const toPgTemplateValues = (values: Array<unknown>): Array<Postgres.ParameterOrFragment<never>> =>
+  values as unknown as Array<Postgres.ParameterOrFragment<never>>
+
+const toPgUnsafeValues = (
+  values?: Array<unknown>,
+): Array<Postgres.ParameterOrJSON<never>> | undefined =>
+  values === undefined ? undefined : (values as unknown as Array<Postgres.ParameterOrJSON<never>>)
+
+const getErrorCode = (error: unknown): string => {
+  if (error !== null && typeof error === "object" && "code" in error) {
+    const code = (error as { readonly code: unknown }).code
+    if (typeof code === "string") {
+      return code
+    }
+  }
+  return "UNKNOWN"
+}
+
+const wrapError = (error: unknown): SqlClient.SqlError =>
+  new SqlClient.SqlError({
+    code: getErrorCode(error),
+    message: error instanceof Error ? error.message : String(error),
+    cause: error,
+  })
+
+interface TxState {
+  readonly conn: Postgres.ReservedSql
+  readonly depth: number
+}
+
+const currentTransaction = GlobalValue.globalValue(
+  Symbol.for("effect-start/sql/postgres/currentTransaction"),
+  () => FiberRef.unsafeMake<Option.Option<TxState>>(Option.none()),
+)
+
+const runTemplate = <T extends object = SqlClient.SqlRow>(
+  pg: Postgres.Sql,
+  strings: TemplateStringsArray,
+  values: Array<unknown>,
+): Effect.Effect<ReadonlyArray<T>, SqlClient.SqlError> =>
+  Effect.flatMap(FiberRef.get(currentTransaction), (txOpt) =>
+    Effect.tryPromise({
+      try: () => {
+        const args = toPgTemplateValues(values)
+        if (Option.isSome(txOpt)) {
+          return Promise.resolve(
+            txOpt.value.conn<ReadonlyArray<T>>(strings, ...args) as unknown as ReadonlyArray<T>,
+          )
+        }
+        return Promise.resolve(
+          pg<ReadonlyArray<T>>(strings, ...args) as unknown as ReadonlyArray<T>,
+        )
+      },
+      catch: wrapError,
+    }),
+  )
+
+const runUnsafe = <T extends object = SqlClient.SqlRow>(
+  pg: Postgres.Sql,
+  query: string,
+  values?: Array<unknown>,
+): Effect.Effect<ReadonlyArray<T>, SqlClient.SqlError> =>
+  Effect.flatMap(FiberRef.get(currentTransaction), (txOpt) =>
+    Effect.tryPromise({
+      try: () => {
+        const args = toPgUnsafeValues(values)
+        if (Option.isSome(txOpt)) {
+          return Promise.resolve(
+            txOpt.value.conn.unsafe<Array<T>>(query, args) as unknown as ReadonlyArray<T>,
+          )
+        }
+        return Promise.resolve(pg.unsafe<Array<T>>(query, args) as unknown as ReadonlyArray<T>)
+      },
+      catch: wrapError,
+    }),
+  )
+
+const makeWithTransaction =
+  (pg: Postgres.Sql) =>
+  <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)) {
+          const { conn, depth } = txOpt.value
+          const name = `sp_${depth}`
+          return Effect.gen(function* () {
+            yield* Effect.tryPromise({
+              try: () => Promise.resolve(conn.unsafe(`SAVEPOINT ${name}`)),
+              catch: wrapError,
+            })
+            const exit = yield* Effect.exit(
+              restore(
+                Effect.locally(self, currentTransaction, Option.some({ conn, depth: depth + 1 })),
+              ),
+            )
+            if (Exit.isSuccess(exit)) {
+              yield* Effect.tryPromise({
+                try: () => Promise.resolve(conn.unsafe(`RELEASE SAVEPOINT ${name}`)),
+                catch: wrapError,
+              })
+              return exit.value
+            }
+            yield* Effect.tryPromise({
+              try: () => Promise.resolve(conn.unsafe(`ROLLBACK TO SAVEPOINT ${name}`)),
+              catch: wrapError,
+            }).pipe(Effect.orDie)
+            return yield* exit
+          })
+        }
+
+        return Effect.acquireUseRelease(
+          Effect.tryPromise({ try: () => pg.reserve(), catch: wrapError }),
+          (reserved) =>
+            Effect.gen(function* () {
+              yield* Effect.tryPromise({
+                try: () => Promise.resolve(reserved.unsafe("BEGIN")),
+                catch: wrapError,
+              })
+              const exit = yield* Effect.exit(
+                restore(
+                  Effect.locally(
+                    self,
+                    currentTransaction,
+                    Option.some({ conn: reserved, depth: 1 }),
+                  ),
+                ),
+              )
+              if (Exit.isSuccess(exit)) {
+                yield* Effect.tryPromise({
+                  try: () => Promise.resolve(reserved.unsafe("COMMIT")),
+                  catch: wrapError,
+                })
+                return exit.value
+              }
+              yield* Effect.tryPromise({
+                try: () => Promise.resolve(reserved.unsafe("ROLLBACK")),
+                catch: wrapError,
+              }).pipe(Effect.orDie)
+              return yield* exit
+            }),
+          (reserved) => Effect.sync(() => reserved.release()),
+        )
+      }),
+    )
+
+const dialect = SqlClient.postgresDialect
+const spanAttributes: ReadonlyArray<readonly [string, unknown]> = [["db.system.name", "postgresql"]]
+
+const makeTaggedTemplate = (pg: Postgres.Sql) => {
+  const unsafeFn: SqlClient.UnsafeQuery = <T extends object = SqlClient.SqlRow>(
+    query: string,
+    values?: Array<unknown>,
+  ) => runUnsafe<T>(pg, query, values)
+
+  const query = <T extends object = SqlClient.SqlRow>(
+    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)
+    }
+    return runTemplate<T>(pg, strings, values)
+  }
+
+  return { query, unsafeFn }
+}
+
+const makeReservedConnection = (reserved: Postgres.ReservedSql): SqlClient.Connection => {
+  const query = <T extends object = SqlClient.SqlRow>(
+    strings: TemplateStringsArray,
+    ...values: Array<unknown>
+  ): Effect.Effect<ReadonlyArray<T>, SqlClient.SqlError> =>
+    Effect.tryPromise({
+      try: () =>
+        Promise.resolve(
+          reserved<ReadonlyArray<T>>(
+            strings,
+            ...toPgTemplateValues(values),
+          ) as unknown as ReadonlyArray<T>,
+        ),
+      catch: wrapError,
+    })
+
+  const unsafe: SqlClient.UnsafeQuery = <T extends object = SqlClient.SqlRow>(
+    queryText: string,
+    values?: Array<unknown>,
+  ): Effect.Effect<ReadonlyArray<T>, SqlClient.SqlError> =>
+    Effect.tryPromise({
+      try: () =>
+        Promise.resolve(
+          reserved.unsafe<Array<T>>(
+            queryText,
+            toPgUnsafeValues(values),
+          ) as unknown as ReadonlyArray<T>,
+        ),
+      catch: wrapError,
+    })
+
+  return SqlClient.connection(query, unsafe, { spanAttributes, dialect })
+}
+
+export const layer = (config: PgConfig): Layer.Layer<SqlClient.SqlClient, SqlClient.SqlError> =>
+  Layer.scoped(
+    SqlClient.SqlClient,
+    Effect.map(
+      Effect.acquireRelease(
+        Effect.try({
+          try: () => {
+            const pg =
+              typeof config === "string"
+                ? postgres(config)
+                : postgres(config as Postgres.Options<Record<string, Postgres.PostgresType>>)
+            const tagged = makeTaggedTemplate(pg)
+            const use: SqlClient.SqlClient["use"] = (fn) =>
+              Effect.tryPromise({ try: () => Promise.resolve(fn(pg)), catch: wrapError })
+
+            return {
+              client: SqlClient.make({
+                query: tagged.query,
+                unsafe: tagged.unsafeFn,
+                withTransaction: makeWithTransaction(pg),
+                spanAttributes,
+                dialect,
+                reserve: Effect.acquireRelease(
+                  Effect.tryPromise({ try: () => pg.reserve(), catch: wrapError }),
+                  (reserved: Postgres.ReservedSql) => Effect.sync(() => reserved.release()),
+                ).pipe(
+                  Effect.map((reserved): SqlClient.Connection => makeReservedConnection(reserved)),
+                ),
+                use,
+              }),
+              close: use((driver) => (driver as Postgres.Sql).end({ timeout: 0 })),
+            }
+          },
+          catch: wrapError,
+        }),
+        (handle) => handle.close.pipe(Effect.orDie),
+      ),
+      (handle) => handle.client,
+    ),
+  )