sailfork / t3code-github / .repos/ effect/ packages/ sql/ pg/ src/ internal/ config.ts

import * as Duration from "effect/Duration"
import * as Effect from "effect/Effect"
import * as Option from "effect/Option"
import * as Redacted from "effect/Redacted"
import * as EffectResult from "effect/Result"
import { ConnectionError, SqlError } from "effect/sql/SqlError"
import type { Duplex } from "node:stream"
import type { ConnectionOptions } from "node:tls"
import type { Config } from "../PgConnection.ts"
import type * as PgProtocol from "../PgProtocol.ts"

export interface ResolvedConfig {
  readonly host: string
  readonly port: number
  readonly path: string | undefined
  readonly ssl: boolean | ConnectionOptions
  readonly sslOptional: boolean
  readonly username: string
  readonly password: Redacted.Redacted | Effect.Effect<Redacted.Redacted> | undefined
  readonly connectTimeout: Duration.Duration
  readonly keepAlive: number | undefined
  readonly startupParameters: PgProtocol.StartupParameters
  readonly stream: (() => Duplex) | undefined
  readonly maxMessageSize: number | undefined
}

const configError = (message: string, cause?: unknown): SqlError =>
  new SqlError({
    reason: new ConnectionError({
      cause: cause ?? new Error(message),
      message: `PgConnection: ${message}`,
      operation: "connect"
    })
  })

// Node truncates to whole seconds and libuv silently ignores zero, which would
// leave the OS defaults in place.
const keepAliveMillis = (input: Duration.Input): number | undefined => {
  const duration = Duration.fromInput(input)
  if (Option.isNone(duration)) return undefined
  const seconds = Math.floor(Duration.toSeconds(duration.value))
  return seconds >= 1 && seconds <= 0x7fffffff ? seconds * 1000 : undefined
}

export const resolveConfig = (options: Config): Effect.Effect<ResolvedConfig, SqlError> =>
  Effect.suspend(() => {
    const parsed: EffectResult.Result<UrlConfig, SqlError> = options.url !== undefined
      ? parseUrl(Redacted.value(options.url))
      : EffectResult.succeed({})
    if (EffectResult.isFailure(parsed)) return Effect.fail(parsed.failure)
    const url = parsed.success
    const host = options.host ?? url.host ?? "localhost"
    const port = options.port ?? url.port ?? 5432
    const username = options.username ?? url.username ?? process.env.USER ?? process.env.USERNAME
    if (username === undefined) {
      return Effect.fail(configError("No username configured"))
    }
    const keepAlive = options.keepAlive === undefined ? undefined : keepAliveMillis(options.keepAlive)
    if (options.keepAlive !== undefined && keepAlive === undefined) {
      return Effect.fail(configError("keepAlive must be between 1 and 2147483647 seconds"))
    }
    const named: Record<string, string> = Object.create(null)
    for (const [name, value] of Object.entries(options.startupParameters ?? {})) {
      const key = name.toLowerCase()
      if (key === "user" || key === "database" || key === "replication" || key === "options") {
        return Effect.fail(configError(`Reserved startup parameter: "${name}"`))
      }
      if (key === "client_encoding") {
        const encoding = value.toUpperCase()
        if (encoding !== "UTF8" && encoding !== "UTF-8") {
          return Effect.fail(configError("Startup parameter client_encoding must be UTF8 or UTF-8"))
        }
        named[key] = "UTF8"
      } else {
        named[key] = value
      }
      if (name === "" || name.includes("\0") || value.includes("\0")) {
        return Effect.fail(
          configError("Startup parameter names must be nonempty and names/values must not contain NUL")
        )
      }
    }
    const startupParameters: PgProtocol.StartupParameters = {
      ...named,
      user: username,
      database: options.database ?? url.database,
      application_name: options.applicationName ?? named.application_name ?? url.applicationName ?? "@effect/sql-pg",
      options: options.startupOptions ?? url.options
    }
    for (const [name, value] of Object.entries(startupParameters)) {
      if (value?.includes("\0")) {
        return Effect.fail(configError(`Startup parameter "${name}" must not contain NUL`))
      }
    }
    return Effect.succeed<ResolvedConfig>({
      host,
      port,
      path: options.path ?? (host.startsWith("/") ? `${host}/.s.PGSQL.${port}` : undefined),
      ssl: options.ssl ?? (url.ssl === "prefer" ? true : url.ssl ?? false),
      sslOptional: options.ssl === undefined && url.ssl === "prefer",
      username,
      password: options.password ?? (url.password !== undefined ? Redacted.make(url.password) : undefined),
      connectTimeout: Duration.fromInputUnsafe(options.connectTimeout ?? url.connectTimeout ?? Duration.seconds(5)),
      keepAlive,
      startupParameters,
      stream: options.stream,
      maxMessageSize: options.maxMessageSize
    })
  })

interface UrlConfig {
  host?: string | undefined
  port?: number | undefined
  database?: string | undefined
  username?: string | undefined
  password?: string | undefined
  applicationName?: string | undefined
  options?: string | undefined
  connectTimeout?: Duration.Duration | undefined
  ssl?: boolean | "prefer" | undefined
}

const decodeComponent = (value: string, what: string): EffectResult.Result<string, SqlError> => {
  try {
    return EffectResult.succeed(decodeURIComponent(value))
  } catch {
    return EffectResult.fail(configError(`Invalid percent-encoding in URL ${what}`))
  }
}

const parsePort = (value: string, what: string): EffectResult.Result<number, SqlError> => {
  const port = Number(value)
  return !Number.isInteger(port) || port < 1 || port > 65535
    ? EffectResult.fail(configError(`Invalid port in URL ${what}: "${value}"`))
    : EffectResult.succeed(port)
}

const parseUrl = (raw: string): EffectResult.Result<UrlConfig, SqlError> => {
  let url: URL
  try {
    url = new URL(raw)
  } catch (cause) {
    return EffectResult.fail(configError("Invalid connection URL", cause))
  }
  if (url.protocol !== "postgres:" && url.protocol !== "postgresql:") {
    return EffectResult.fail(configError(`Unsupported connection URL protocol: "${url.protocol}"`))
  }

  const config: UrlConfig = {}
  if (url.hostname !== "") {
    if (url.hostname.startsWith("[") && url.hostname.endsWith("]")) {
      config.host = url.hostname.slice(1, -1)
    } else {
      const host = decodeComponent(url.hostname, "host")
      if (EffectResult.isFailure(host)) return EffectResult.fail(host.failure)
      config.host = host.success
    }
  }
  if (url.port !== "") {
    const port = parsePort(url.port, "authority")
    if (EffectResult.isFailure(port)) return EffectResult.fail(port.failure)
    config.port = port.success
  }
  if (url.username !== "") {
    const username = decodeComponent(url.username, "username")
    if (EffectResult.isFailure(username)) return EffectResult.fail(username.failure)
    config.username = username.success
  }
  if (url.password !== "") {
    const password = decodeComponent(url.password, "password")
    if (EffectResult.isFailure(password)) return EffectResult.fail(password.failure)
    config.password = password.success
  }
  const database = decodeComponent(url.pathname.replace(/^\//, ""), "database")
  if (EffectResult.isFailure(database)) return EffectResult.fail(database.failure)
  if (database.success !== "") config.database = database.success

  for (const [key, value] of url.searchParams) {
    switch (key) {
      case "host":
        config.host = value
        break
      case "port": {
        const port = parsePort(value, "port parameter")
        if (EffectResult.isFailure(port)) return EffectResult.fail(port.failure)
        config.port = port.success
        break
      }
      case "user":
        config.username = value
        break
      case "password":
        config.password = value
        break
      case "dbname":
        config.database = value
        break
      case "application_name":
        config.applicationName = value
        break
      case "options":
        config.options = value
        break
      case "connect_timeout": {
        const seconds = Number(value)
        if (!Number.isInteger(seconds) || seconds < 0) {
          return EffectResult.fail(configError(`Invalid connect_timeout in URL: "${value}"`))
        }
        config.connectTimeout = seconds === 0 ? Duration.infinity : Duration.seconds(seconds)
        break
      }
      case "sslmode":
        switch (value) {
          case "disable":
            config.ssl = false
            break
          case "require":
          case "verify-ca":
          case "verify-full":
            config.ssl = true
            break
          case "prefer":
          case "allow":
            config.ssl = "prefer"
            break
          default:
            return EffectResult.fail(configError(`Unrecognized sslmode in URL: "${value}"`))
        }
        break
        // Unknown query parameters are ignored, matching libpq.
    }
  }
  return EffectResult.succeed(config)
}