sailfork / t3code-github / .repos/ effect/ packages/ platform/ deno/ src/ DenoDns.ts

/**
 * Deno-backed implementation of Effect's `Dns` service.
 *
 * Address lookups use the operating system resolver through Deno's `node:dns`
 * compatibility layer, so they also read the hosts file. Record queries and
 * reverse lookups use `Deno.resolveDns` and can be cancelled by interruption.
 * Records whose data cannot be represented, such as names that are not valid
 * `Host.DomainName` values, are skipped, and a query fails with
 * `InvalidResponse` when every record is skipped.
 *
 * **Gotchas**
 *
 * `Deno.resolveDns` reports every error response from the name server with the
 * same error as a missing name, so refused queries and server failures
 * (`REFUSED`, `SERVFAIL`, `FORMERR`, `NOTIMP`) fail with `NotFound` instead of
 * `Refused`, `ServerFailure`, `InvalidResponse`, or `Unsupported`. Server
 * failures are therefore not reported as temporary. `Deno.resolveDns` cannot
 * query TLSA records, so TLSA queries fail with `Unsupported`. Queries require
 * the `--allow-net` permission.
 *
 * @stability experimental
 * @since 4.0.0
 */
import * as NodeDns from "@effect/platform-node-shared/NodeDns"
import type * as Arr from "effect/Array"
import * as Config from "effect/Config"
import * as Duration from "effect/Duration"
import * as Effect from "effect/Effect"
import * as Layer from "effect/Layer"
import * as Dns from "effect/net/Dns"
import * as NetAddress from "effect/net/NetAddress"
import * as Result from "effect/Result"

/**
 * Options for the Deno `Dns` service.
 *
 * **Details**
 *
 * `nameServer` replaces the system name server for record queries and reverse
 * lookups and is converted like `Dns.nameServerFromInput`. Address
 * lookups always use the operating system resolver.
 *
 * **Gotchas**
 *
 * Invalid name servers fail with a `NetAddress.NetAddressError` when the
 * service is created, and so do IPv6 name servers with a scope ID, such as
 * link-local addresses.
 *
 * @stability experimental
 * @category models
 * @since 4.0.0
 */
export interface Options {
  readonly nameServer?: NetAddress.IpAddressInput | NetAddress.InetAddressInput | undefined
}

const reasons: Record<string, Dns.DnsErrorReason> = {
  NotFound: "NotFound",
  TimedOut: "Timeout",
  ConnectionRefused: "Refused",
  InvalidData: "InvalidResponse",
  NotSupported: "Unsupported"
}

const toDnsError = (cause: unknown, name: string, type: Dns.RecordType): Dns.DnsError =>
  new Dns.DnsError({
    reason: (cause instanceof Error ? reasons[cause.name] : undefined) ?? "Unknown",
    method: "resolve",
    hostname: name,
    recordType: type,
    cause
  })

const queries: {
  readonly [K in Dns.RecordType]: (
    name: string,
    options: Deno.ResolveDnsOptions
  ) => Promise<Result.Result<Array<Dns.DnsRecord>, Dns.DnsError>>
} = {
  A: async (name, options) =>
    NodeDns.recordsFromResolver(name, "A", await Deno.resolveDns(name, "A", options), (address) => ({
      address: NetAddress.ipFromStringUnsafe(address) as NetAddress.Ipv4Address
    })),
  AAAA: async (name, options) =>
    NodeDns.recordsFromResolver(name, "AAAA", await Deno.resolveDns(name, "AAAA", options), (address) => ({
      address: NetAddress.ipFromStringUnsafe(address) as NetAddress.Ipv6Address
    })),
  CAA: async (name, options) =>
    NodeDns.recordsFromResolver(name, "CAA", await Deno.resolveDns(name, "CAA", options), (caa) => ({
      critical: caa.critical,
      tag: caa.tag,
      value: caa.value
    })),
  CNAME: async (name, options) =>
    NodeDns.recordsFromResolver(name, "CNAME", await Deno.resolveDns(name, "CNAME", options), (target) => ({
      target: NodeDns.domainNameFromResolverUnsafe(target)
    })),
  MX: async (name, options) =>
    NodeDns.recordsFromResolver(name, "MX", await Deno.resolveDns(name, "MX", options), (mx) => ({
      exchange: NodeDns.domainNameFromResolverUnsafe(mx.exchange),
      priority: mx.preference
    })),
  NAPTR: async (name, options) =>
    NodeDns.recordsFromResolver(name, "NAPTR", await Deno.resolveDns(name, "NAPTR", options), (naptr) => ({
      order: naptr.order,
      preference: naptr.preference,
      flags: naptr.flags,
      service: naptr.services,
      regexp: naptr.regexp,
      replacement: NodeDns.domainNameFromResolverUnsafe(naptr.replacement)
    })),
  NS: async (name, options) =>
    NodeDns.recordsFromResolver(name, "NS", await Deno.resolveDns(name, "NS", options), (host) => ({
      host: NodeDns.domainNameFromResolverUnsafe(host)
    })),
  PTR: async (name, options) =>
    NodeDns.recordsFromResolver(name, "PTR", await Deno.resolveDns(name, "PTR", options), (host) => ({
      host: NodeDns.nameTextFromResolver(host, 8)
    })),
  SOA: async (name, options) =>
    NodeDns.recordsFromResolver(name, "SOA", await Deno.resolveDns(name, "SOA", options), (soa) => ({
      primary: NodeDns.domainNameFromResolverUnsafe(soa.mname),
      admin: NodeDns.nameTextFromResolver(soa.rname, 8),
      serial: soa.serial,
      refresh: NodeDns.secondsFromInt32(soa.refresh),
      retry: NodeDns.secondsFromInt32(soa.retry),
      expire: NodeDns.secondsFromInt32(soa.expire),
      minimum: Duration.seconds(soa.minimum)
    })),
  SRV: async (name, options) =>
    NodeDns.recordsFromResolver(name, "SRV", await Deno.resolveDns(name, "SRV", options), (srv) => ({
      target: NodeDns.domainNameFromResolverUnsafe(srv.target),
      port: srv.port,
      priority: srv.priority,
      weight: srv.weight
    })),
  TLSA: async (name) =>
    Result.fail(new Dns.DnsError({ reason: "Unsupported", method: "resolve", hostname: name, recordType: "TLSA" })),
  TXT: async (name, options) =>
    NodeDns.recordsFromResolver(name, "TXT", await Deno.resolveDns(name, "TXT", options), (chunks) => ({
      chunks: chunks.map(NodeDns.utf8FromLatin1) as unknown as Arr.NonEmptyReadonlyArray<string>
    }))
}

/**
 * Creates a Deno `Dns` service.
 *
 * @stability experimental
 * @category constructors
 * @since 4.0.0
 */
export const make = Effect.fnUntraced(function*(options?: Options) {
  const input = options?.nameServer
  const server = input === undefined ? undefined : yield* Effect.fromResult(Dns.nameServerFromInput(input))
  if (server !== undefined && NetAddress.isInetAddressV6(server) && server.scopeId !== 0) {
    return yield* new NetAddress.NetAddressError({
      input: input!,
      message: "IPv6 name servers with a scope ID are not supported"
    })
  }
  const nameServer: Deno.ResolveDnsOptions["nameServer"] = server === undefined
    ? undefined
    : { ipAddr: NetAddress.formatHost(server), port: server.port }

  return Dns.make({
    lookup: NodeDns.lookup,
    resolve: (name, type) =>
      Effect.tryPromise({
        try: (signal) => queries[type](name, nameServer === undefined ? { signal } : { nameServer, signal }),
        catch: (cause) => toDnsError(cause, name, type)
      }).pipe(Effect.flatMap(Effect.fromResult))
  })
})

/**
 * Layer that provides the Deno `Dns` service using the system resolver
 * configuration.
 *
 * @stability experimental
 * @category layers
 * @since 4.0.0
 */
export const layer: Layer.Layer<Dns.Dns> = Layer.effect(Dns.Dns, Effect.orDie(make()))

/**
 * Creates a layer that provides the Deno `Dns` service with options read
 * from configuration.
 *
 * @stability experimental
 * @category layers
 * @since 4.0.0
 */
export const layerConfig = (
  options: Config.Wrap<Options>
): Layer.Layer<Dns.Dns, Config.ConfigError | NetAddress.NetAddressError> =>
  Layer.effect(Dns.Dns, Effect.flatMap(Config.unwrap(options), make))