@nyc-transit-kit/soda3 0.2.0 → 0.3.0

package/src/internal/transport.ts

@@ -1,161 +0,0 @@
-import {
-  Soda3CatalogSearchResponse,
-  type Soda3ExportRequest,
-  type Soda3QueryRequest,
-  Soda3QueryResponse,
-  Soda3Row
-} from "@nyc-transit-kit/contracts/soda3"
-import * as Effect from "effect/Effect"
-import * as Schema from "effect/Schema"
-import * as HttpClient from "effect/unstable/http/HttpClient"
-import type * as HttpClientError from "effect/unstable/http/HttpClientError"
-import type * as HttpClientRequest from "effect/unstable/http/HttpClientRequest"
-import type * as HttpClientResponse from "effect/unstable/http/HttpClientResponse"
-import { Soda3ClientConfig, type Soda3ClientConfigShape } from "../client"
-import type { Soda3ClientError } from "../errors"
-import {
-  isRetryableProviderError,
-  ProviderContractError,
-  ProviderHttpError,
-  RetryExhaustedError,
-  TimeoutError
-} from "../errors"
-import {
-  httpFailureInfo,
-  httpStatusText,
-  isOkStatus,
-  retryableStatus,
-  withRequestPolicy
-} from "../transport"
-
-export { retryableStatus, toWebResponse } from "../transport"
-
-const providerRows = Schema.Array(Soda3Row)
-
-const decodeUnknown = <S extends Schema.Top>(schema: S, input: unknown) =>
-  Schema.decodeUnknownEffect(schema)(input)
-
-export const addHeaders = (config: Soda3ClientConfigShape) => ({
-  accept: "application/json",
-  ...(config.appToken !== undefined && config.appToken.length > 0
-    ? { "X-App-Token": config.appToken }
-    : {})
-})
-
-export const toQueryBody = (request: Soda3QueryRequest) => ({
-  query: request.query,
-  page: request.page,
-  parameters: request.parameters,
-  timeout: request.timeout,
-  includeSystem: request.includeSystem,
-  includeSynthetic: request.includeSynthetic,
-  orderingSpecifier: request.orderingSpecifier
-})
-
-export const toExportBody = (request: Soda3ExportRequest) => ({
-  query: request.query,
-  parameters: request.parameters,
-  timeout: request.timeout,
-  serializationOptions: request.serializationOptions
-})
-
-export const rangeHeader = (request: Soda3ExportRequest) =>
-  request.range === undefined
-    ? undefined
-    : `bytes=${request.range.start}-${request.range.end ?? ""}`
-
-export const mapHttpClientError = (operation: string, error: HttpClientError.HttpClientError) => {
-  const info = httpFailureInfo(error)
-
-  return ProviderHttpError.make({
-    operation,
-    status: info.status,
-    statusText: info.statusText,
-    retryable: info.status === 0 || retryableStatus(info.status)
-  })
-}
-
-export const decodeJson = (operation: string, response: HttpClientResponse.HttpClientResponse) =>
-  response.json.pipe(
-    Effect.catchTag("HttpClientError", () =>
-      Effect.fail(
-        ProviderContractError.make({
-          operation,
-          message: "Provider response was not valid JSON"
-        })
-      )
-    )
-  )
-
-export const decodeQueryResponse = (input: unknown) =>
-  decodeUnknown(Soda3QueryResponse, input).pipe(
-    Effect.catchTag("SchemaError", (error) =>
-      decodeUnknown(providerRows, input).pipe(
-        Effect.map((rows) =>
-          Soda3QueryResponse.make({
-            rows
-          })
-        ),
-        Effect.catchTag("SchemaError", () =>
-          Effect.fail(
-            ProviderContractError.make({
-              operation: "query",
-              message: error.message
-            })
-          )
-        )
-      )
-    )
-  )
-
-export const decodeCatalogSearchResponse = (input: unknown) =>
-  decodeUnknown(Soda3CatalogSearchResponse, input).pipe(
-    Effect.catchTag("SchemaError", (error) =>
-      Effect.fail(
-        ProviderContractError.make({
-          operation: "catalog",
-          message: error.message
-        })
-      )
-    )
-  )
-
-export const requestWithPolicy = <A>(
-  operation: string,
-  effect: Effect.Effect<A, Soda3ClientError, HttpClient.HttpClient | Soda3ClientConfig>
-) =>
-  Effect.gen(function* () {
-    const config = yield* Soda3ClientConfig
-    return yield* withRequestPolicy(config, effect, {
-      isRetryable: isRetryableProviderError,
-      onExhausted: (attempts, error) =>
-        RetryExhaustedError.make({
-          operation,
-          attempts,
-          message: `Retry attempts exhausted after provider status ${error.status}`
-        }),
-      onTimeout: (timeoutMs) =>
-        TimeoutError.make({
-          operation,
-          timeoutMs
-        })
-    })
-  })
-
-export const executeRequest = (operation: string, request: HttpClientRequest.HttpClientRequest) =>
-  Effect.gen(function* () {
-    const response = yield* HttpClient.execute(request).pipe(
-      Effect.mapError((error) => mapHttpClientError(operation, error))
-    )
-
-    if (!isOkStatus(response.status)) {
-      return yield* ProviderHttpError.make({
-        operation,
-        status: response.status,
-        statusText: httpStatusText(response.status),
-        retryable: retryableStatus(response.status)
-      })
-    }
-
-    return response
-  })

package/src/metadata.ts

@@ -1,37 +0,0 @@
-import {
-  type Soda3CatalogResultFragment,
-  Soda3DatasetMetadataRequest,
-  type Soda3DatasetMetadataRequestInput
-} from "@nyc-transit-kit/contracts/soda3"
-import * as Effect from "effect/Effect"
-import { catalogSearch } from "./catalog"
-import { ProviderContractError } from "./errors"
-import { decodeInput } from "./internal/decode"
-
-export type { Soda3DatasetMetadataRequestInput }
-
-const decodeDatasetMetadataRequest = decodeInput("metadata", Soda3DatasetMetadataRequest)
-
-const matchingResult = (results: ReadonlyArray<Soda3CatalogResultFragment>, datasetId: string) =>
-  results.find((result) => String(result.resource.id) === datasetId)
-
-export const fetchDatasetMetadata = Effect.fn("Soda3.fetchDatasetMetadata")(function* (
-  input: Soda3DatasetMetadataRequestInput
-) {
-  const request = yield* decodeDatasetMetadataRequest(input)
-  const response = yield* catalogSearch({
-    domain: request.domain,
-    ids: [request.datasetId],
-    limit: 1
-  })
-  const result = matchingResult(response.results, String(request.datasetId))
-
-  if (result === undefined) {
-    return yield* ProviderContractError.make({
-      operation: "metadata",
-      message: `Discovery metadata response did not include dataset ${request.datasetId}`
-    })
-  }
-
-  return result
-})

package/src/query.ts

@@ -1,138 +0,0 @@
-import {
-  PositiveInteger,
-  type Soda3QueryRequestInput,
-  type Soda3Row
-} from "@nyc-transit-kit/contracts/soda3"
-import * as Effect from "effect/Effect"
-import * as HttpClientRequest from "effect/unstable/http/HttpClientRequest"
-import { Soda3ClientConfig } from "./client"
-import { buildQueryUrl, decodeSoda3QueryRequest } from "./endpoints"
-import { InvalidInputError, ProviderContractError } from "./errors"
-import { decodeInput } from "./internal/decode"
-import {
-  addHeaders,
-  decodeJson,
-  decodeQueryResponse,
-  executeRequest,
-  requestWithPolicy,
-  toQueryBody
-} from "./internal/transport"
-
-export type { Soda3QueryRequestInput }
-
-export type Soda3QueryAllRowsInput = Omit<Soda3QueryRequestInput, "page"> & {
-  readonly pageSize?: number
-  readonly maxRows?: number
-}
-
-export type Soda3CountRowsInput = {
-  readonly domain: string
-  readonly datasetId: string
-  readonly where?: string
-  readonly parameters?: Readonly<Record<string, unknown>>
-}
-
-const decodeHelperPositiveInteger = (name: string, value: number) =>
-  decodeInput(
-    "query",
-    PositiveInteger
-  )(value).pipe(
-    Effect.mapError((error) =>
-      InvalidInputError.make({
-        operation: "query",
-        message: `Invalid ${name}: ${error.message}`
-      })
-    )
-  )
-
-const decodeOptionalHelperPositiveInteger = (name: string, value: number | undefined) =>
-  value === undefined ? Effect.void : decodeHelperPositiveInteger(name, value)
-
-const decodeCountValue = (value: unknown) => {
-  const parsed =
-    typeof value === "number" ? value : typeof value === "string" ? Number(value) : Number.NaN
-
-  return Number.isInteger(parsed) && parsed >= 0 ? parsed : undefined
-}
-
-const countColumnName = "count"
-
-export const queryRows = Effect.fn("Soda3.queryRows")(function* (input: Soda3QueryRequestInput) {
-  const config = yield* Soda3ClientConfig
-  const queryRequest = yield* decodeSoda3QueryRequest(input)
-  const url = yield* buildQueryUrl(queryRequest)
-  const request = yield* HttpClientRequest.post(url, {
-    headers: addHeaders(config)
-  }).pipe(
-    HttpClientRequest.bodyJson(toQueryBody(queryRequest)),
-    Effect.mapError(() =>
-      InvalidInputError.make({
-        operation: "query",
-        message: "SODA3 query body was not JSON serializable"
-      })
-    )
-  )
-
-  return yield* requestWithPolicy(
-    "query",
-    executeRequest("query", request).pipe(
-      Effect.flatMap((response) => decodeJson("query", response)),
-      Effect.flatMap(decodeQueryResponse)
-    )
-  )
-})
-
-export const queryAllRows = Effect.fn("Soda3.queryAllRows")(function* (
-  input: Soda3QueryAllRowsInput
-) {
-  const { pageSize: rawPageSize = 1000, maxRows: rawMaxRows, ...queryInput } = input
-  const pageSize = yield* decodeHelperPositiveInteger("pageSize", rawPageSize)
-  const maxRows = yield* decodeOptionalHelperPositiveInteger("maxRows", rawMaxRows)
-  const rows: Array<Soda3Row> = []
-  let pageNumber = 1
-
-  while (true) {
-    const response = yield* queryRows({
-      ...queryInput,
-      page: {
-        pageNumber,
-        pageSize
-      }
-    })
-    rows.push(...response.rows)
-
-    if (maxRows !== undefined && rows.length > maxRows) {
-      return yield* InvalidInputError.make({
-        operation: "query",
-        message: `SODA3 query exceeded maxRows=${maxRows}; narrow the query or raise maxRows`
-      })
-    }
-
-    if (response.rows.length < pageSize) {
-      return rows
-    }
-
-    pageNumber += 1
-  }
-})
-
-export const countRows = Effect.fn("Soda3.countRows")(function* (input: Soda3CountRowsInput) {
-  const query = `SELECT count(*)${input.where === undefined ? "" : ` WHERE ${input.where}`}`
-  const response = yield* queryRows({
-    domain: input.domain,
-    datasetId: input.datasetId,
-    query,
-    ...(input.parameters === undefined ? {} : { parameters: input.parameters }),
-    includeSynthetic: false
-  })
-  const count = decodeCountValue(response.rows[0]?.[countColumnName])
-
-  if (count === undefined) {
-    return yield* ProviderContractError.make({
-      operation: "query",
-      message: "SODA3 count(*) response did not include a numeric count"
-    })
-  }
-
-  return count
-})

package/src/soql.ts

@@ -1,214 +0,0 @@
-import { IsoDate } from "@nyc-transit-kit/contracts/ids"
-import { PositiveInteger } from "@nyc-transit-kit/contracts/soda3"
-import * as Effect from "effect/Effect"
-import * as Schema from "effect/Schema"
-import { InvalidInputError } from "./errors"
-import { decodeInput } from "./internal/decode"
-export const soqlSelectAll = "SELECT *"
-export type SoqlParameters = Readonly<Record<string, unknown>>
-export type SoqlFragment = Readonly<{ text: string; parameters?: SoqlParameters }>
-export type SocrataTimestampWindow = Readonly<{ start: string; end: string }>
-export type SocrataYearMonth = Readonly<{ year: number; month: number }>
-const fn = Effect.fn
-const identifierPattern = /^[A-Za-z_][A-Za-z0-9_]*$/
-const parameterPattern = /^[A-Za-z_][A-Za-z0-9_]*$/
-const datePattern = /^(\d{4})-(\d{2})-(\d{2})$/
-const patternString = (pattern: RegExp, message: string) =>
-  Schema.String.pipe(Schema.check(Schema.isPattern(pattern, { message })))
-const SoqlIdentifier = patternString(
-  identifierPattern,
-  "Expected a SoQL identifier such as route_id"
-)
-const SoqlParameterName = patternString(
-  parameterPattern,
-  "Expected a SoQL parameter name such as route"
-)
-const SoqlSortDirection = Schema.Literals(["ASC", "DESC"])
-export type SoqlSortDirection = typeof SoqlSortDirection.Type
-const intRange = (minimum: number, maximum: number) =>
-  Schema.Int.pipe(
-    Schema.check(Schema.isGreaterThanOrEqualTo(minimum)),
-    Schema.check(Schema.isLessThanOrEqualTo(maximum))
-  )
-const SocrataYear = intRange(1900, 9999)
-const SocrataMonth = intRange(1, 12)
-const SocrataYearMonthSchema = Schema.Struct({ year: SocrataYear, month: SocrataMonth })
-const invalidQueryInput = (message: string) =>
-  InvalidInputError.make({ operation: "query", message })
-const decode = <S extends Schema.Top>(schema: S) => decodeInput("query", schema)
-const decodeLimit = decode(PositiveInteger)
-const decodeIdentifier = decode(SoqlIdentifier)
-const decodeParameterName = decode(SoqlParameterName)
-const decodeSortDirection = decode(SoqlSortDirection)
-const decodeIsoDate = decode(IsoDate)
-const decodeYear = decode(SocrataYear)
-const decodeMonth = decode(SocrataMonth)
-const decodeYearMonth = decode(SocrataYearMonthSchema)
-const fragment = (text: string, parameters?: SoqlParameters): SoqlFragment =>
-  parameters === undefined ? { text } : { text, parameters }
-const mergeParameters = (fragments: ReadonlyArray<SoqlFragment>) => {
-  const parameters: Record<string, unknown> = {}
-  for (const part of fragments) {
-    for (const [key, value] of Object.entries(part.parameters ?? {})) {
-      if (Object.hasOwn(parameters, key)) {
-        return Effect.fail(invalidQueryInput(`Duplicate SoQL parameter name: ${key}`))
-      }
-      parameters[key] = value
-    }
-  }
-  return Effect.succeed(Object.keys(parameters).length === 0 ? undefined : parameters)
-}
-const dateMessage = "Expected an ISO calendar date in YYYY-MM-DD format"
-const pad = (value: number, length: number) => value.toString().padStart(length, "0")
-const timestampFromParts = (year: number, month: number, day: number) =>
-  `${pad(year, 4)}-${pad(month, 2)}-${pad(day, 2)}T00:00:00`
-const datePartsOf = (value: string) => {
-  const [, yearText, monthText, dayText] = datePattern.exec(value) ?? []
-  return yearText === undefined || monthText === undefined || dayText === undefined
-    ? Effect.fail(invalidQueryInput(dateMessage))
-    : Effect.succeed({ year: +yearText, month: +monthText, day: +dayText })
-}
-export const soqlLimit = fn("Soda3.soqlLimit")(function* (query: string, limit: unknown) {
-  return `${query} LIMIT ${yield* decodeLimit(limit)}`
-})
-export const soqlIdentifier = fn("Soda3.soqlIdentifier")(function* (input: unknown) {
-  return yield* decodeIdentifier(input)
-})
-export const soqlParameterName = fn("Soda3.soqlParameterName")(function* (input: unknown) {
-  return yield* decodeParameterName(input)
-})
-export const soqlParameter = fn("Soda3.soqlParameter")(function* (name: unknown, value: unknown) {
-  const key = yield* decodeParameterName(name)
-  return fragment(`:${key}`, { [key]: value })
-})
-export const soqlEq = fn("Soda3.soqlEq")(function* (
-  column: unknown,
-  parameterName: unknown,
-  value: unknown
-) {
-  const col = yield* decodeIdentifier(column)
-  const key = yield* decodeParameterName(parameterName)
-  return fragment(`${col} = :${key}`, { [key]: value })
-})
-export const soqlIn = fn("Soda3.soqlIn")(function* (
-  column: unknown,
-  parameterBaseName: unknown,
-  values: ReadonlyArray<unknown>
-) {
-  if (values.length === 0) {
-    return yield* invalidQueryInput("SoQL IN predicates require at least one value")
-  }
-  const col = yield* decodeIdentifier(column)
-  const base = yield* decodeParameterName(parameterBaseName)
-  const parameters: Record<string, unknown> = {}
-  const placeholders: Array<string> = []
-  for (let index = 0; index < values.length; index += 1) {
-    const key = `${base}_${index + 1}`
-    parameters[key] = values[index]
-    placeholders.push(`:${key}`)
-  }
-  return fragment(`${col} IN (${placeholders.join(", ")})`, parameters)
-})
-export const soqlIsNotNull = fn("Soda3.soqlIsNotNull")(function* (column: unknown) {
-  return fragment(`${yield* decodeIdentifier(column)} IS NOT NULL`)
-})
-export const soqlAnd = fn("Soda3.soqlAnd")(function* (fragments: ReadonlyArray<SoqlFragment>) {
-  if (fragments.length === 0) {
-    return yield* invalidQueryInput("SoQL AND composition requires at least one fragment")
-  }
-  return fragment(
-    fragments.map((part) => `(${part.text})`).join(" AND "),
-    yield* mergeParameters(fragments)
-  )
-})
-export const soqlOrderBy = fn("Soda3.soqlOrderBy")(function* (
-  column: unknown,
-  direction: unknown = "ASC"
-) {
-  const col = yield* decodeIdentifier(column)
-  return fragment(`ORDER BY ${col} ${yield* decodeSortDirection(direction)}`)
-})
-export const socrataTimestamp = fn("Soda3.socrataTimestamp")(function* (date: string | Date) {
-  if (date instanceof Date) {
-    if (Number.isNaN(date.getTime())) {
-      return yield* invalidQueryInput("Expected a valid Date")
-    }
-    return timestampFromParts(date.getUTCFullYear(), date.getUTCMonth() + 1, date.getUTCDate())
-  }
-  const decodedDate = yield* decodeIsoDate(date)
-  const parts = yield* datePartsOf(decodedDate)
-  return timestampFromParts(parts.year, parts.month, parts.day)
-})
-export const socrataMonthWindow = fn("Soda3.socrataMonthWindow")(function* (
-  year: unknown,
-  month: unknown
-) {
-  const y = yield* decodeYear(year)
-  const m = yield* decodeMonth(month)
-  const endYear = m === 12 ? y + 1 : y
-  const endMonth = m === 12 ? 1 : m + 1
-  return {
-    start: timestampFromParts(y, m, 1),
-    end: timestampFromParts(endYear, endMonth, 1)
-  }
-})
-export const socrataDateWindow = fn("Soda3.socrataDateWindow")(function* (
-  startDate: unknown,
-  endDate: unknown
-) {
-  const start = yield* datePartsOf(yield* decodeIsoDate(startDate))
-  const end = yield* datePartsOf(yield* decodeIsoDate(endDate))
-  if (
-    Date.UTC(start.year, start.month - 1, start.day) >= Date.UTC(end.year, end.month - 1, end.day)
-  ) {
-    return yield* invalidQueryInput("Socrata date windows require startDate before endDate")
-  }
-  return {
-    start: timestampFromParts(start.year, start.month, start.day),
-    end: timestampFromParts(end.year, end.month, end.day)
-  }
-})
-export const soqlTimestampRange = fn("Soda3.soqlTimestampRange")(function* (
-  column: unknown,
-  startParameterName: unknown,
-  endParameterName: unknown,
-  w: SocrataTimestampWindow
-) {
-  const col = yield* decodeIdentifier(column)
-  const s = yield* decodeParameterName(startParameterName)
-  const e = yield* decodeParameterName(endParameterName)
-  if (s === e) {
-    return yield* invalidQueryInput(`Duplicate SoQL parameter name: ${s}`)
-  }
-  return fragment(`${col} >= :${s} AND ${col} < :${e}`, { [s]: w.start, [e]: w.end })
-})
-export const soqlMonthWindow = fn("Soda3.soqlMonthWindow")(function* (
-  column: unknown,
-  year: unknown,
-  month: unknown,
-  parameterBaseName: unknown
-) {
-  const base = yield* decodeParameterName(parameterBaseName)
-  const window = yield* socrataMonthWindow(year, month)
-  return yield* soqlTimestampRange(column, `${base}_start`, `${base}_end`, window)
-})
-export const soqlYearMonthRange = fn("Soda3.soqlYearMonthRange")(function* (
-  yearColumn: unknown,
-  monthColumn: unknown,
-  start: unknown,
-  end: unknown
-) {
-  const yearCol = yield* decodeIdentifier(yearColumn)
-  const monthCol = yield* decodeIdentifier(monthColumn)
-  const rs = yield* decodeYearMonth(start)
-  const re = yield* decodeYearMonth(end)
-  const startOrder = rs.year * 12 + rs.month
-  const endOrder = re.year * 12 + re.month
-  if (startOrder > endOrder) {
-    return yield* invalidQueryInput("SoQL year/month ranges require start before end")
-  }
-  return fragment(
-    `(${yearCol} > :start_year OR (${yearCol} = :start_year AND ${monthCol} >= :start_month)) AND (${yearCol} < :end_year OR (${yearCol} = :end_year AND ${monthCol} <= :end_month))`,
-    { start_year: rs.year, start_month: rs.month, end_year: re.year, end_month: re.month }
-  )
-})

package/src/transport.ts

@@ -1,145 +0,0 @@
-import * as Duration from "effect/Duration"
-import * as Effect from "effect/Effect"
-import * as Layer from "effect/Layer"
-import * as Schedule from "effect/Schedule"
-import * as Stream from "effect/Stream"
-import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient"
-import type * as Headers from "effect/unstable/http/Headers"
-import type * as HttpClientError from "effect/unstable/http/HttpClientError"
-import type * as HttpClientResponse from "effect/unstable/http/HttpClientResponse"
-
-export type FetchImplementation = (
-  input: string | URL | globalThis.Request,
-  init?: globalThis.RequestInit
-) => Promise<globalThis.Response>
-
-export interface RequestPolicyConfig {
-  readonly retryTimes?: number
-  readonly retryDelayMs?: number
-  readonly timeoutMs?: number
-}
-
-export const httpStatusText = (status: number) => `HTTP ${status}`
-export const retryableStatus = (status: number) => status === 429 || status >= 500
-export const isOkStatus = (status: number) => status >= 200 && status < 300
-
-const retryPolicy = <E>(
-  retryTimes: number,
-  retryDelayMs: number | undefined,
-  isRetryable: (error: E) => boolean
-) =>
-  retryDelayMs === undefined || retryDelayMs <= 0
-    ? {
-        times: retryTimes,
-        while: isRetryable
-      }
-    : {
-        schedule: Schedule.exponential(Duration.millis(retryDelayMs)).pipe(
-          Schedule.both(Schedule.recurs(retryTimes))
-        ),
-        while: isRetryable
-      }
-
-export const withRequestPolicy = <A, E, R, Retryable extends E>(
-  config: RequestPolicyConfig,
-  effect: Effect.Effect<A, E, R>,
-  adapters: {
-    readonly isRetryable: (error: E) => error is Retryable
-    readonly onExhausted: (attempts: number, error: Retryable) => E
-    readonly onTimeout: (timeoutMs: number) => E
-    readonly retryableResult?: (value: A) => E | undefined
-  }
-): Effect.Effect<A, E, R> => {
-  const retryTimes = config.retryTimes ?? 0
-  const effectWithRetryableResults =
-    retryTimes > 0 && adapters.retryableResult !== undefined
-      ? effect.pipe(
-          Effect.flatMap((value) => {
-            const retryableError = adapters.retryableResult?.(value)
-            return retryableError === undefined
-              ? Effect.succeed(value)
-              : Effect.fail(retryableError)
-          })
-        )
-      : effect
-  const retried =
-    retryTimes > 0
-      ? effectWithRetryableResults.pipe(
-          Effect.retry(retryPolicy(retryTimes, config.retryDelayMs, adapters.isRetryable)),
-          Effect.catchIf(adapters.isRetryable, (error) =>
-            Effect.fail(adapters.onExhausted(retryTimes + 1, error))
-          )
-        )
-      : effectWithRetryableResults
-  const timeoutMs = config.timeoutMs
-
-  return timeoutMs === undefined
-    ? retried
-    : retried.pipe(
-        Effect.timeoutOrElse({
-          duration: timeoutMs,
-          orElse: () => Effect.fail(adapters.onTimeout(timeoutMs))
-        })
-      )
-}
-
-export const httpFailureInfo = (error: HttpClientError.HttpClientError) => {
-  const response = error.response
-
-  return response === undefined
-    ? {
-        status: 0,
-        statusText: error.message
-      }
-    : {
-        status: response.status,
-        statusText: httpStatusText(response.status)
-      }
-}
-
-export const toWebResponse = (response: HttpClientResponse.HttpClientResponse) =>
-  Effect.map(
-    Stream.toReadableStreamEffect(response.stream),
-    (body) =>
-      new Response(body, {
-        status: response.status,
-        headers: response.headers
-      })
-  )
-
-export const contentLengthOf = (headers: Headers.Headers) => {
-  const value = headers["content-length"]
-  if (value === undefined) {
-    return undefined
-  }
-  const parsed = Number(value)
-  return Number.isInteger(parsed) && parsed >= 0 ? parsed : undefined
-}
-
-const shouldRedactSearchParameter = (name: string) => {
-  const lower = name.toLowerCase()
-  return lower.includes("key") || lower.includes("token") || lower.includes("secret")
-}
-
-export const redactedUrl = (url: string) => {
-  try {
-    const parsed = new URL(url)
-
-    for (const name of parsed.searchParams.keys()) {
-      if (shouldRedactSearchParameter(name)) {
-        parsed.searchParams.set(name, "REDACTED")
-      }
-    }
-
-    return parsed.toString()
-  } catch {
-    return "[invalid-url]"
-  }
-}
-
-export const fetchHttpClientLayer = (fetchImplementation?: FetchImplementation) =>
-  fetchImplementation === undefined
-    ? FetchHttpClient.layer
-    : FetchHttpClient.layer.pipe(
-        Layer.provide(Layer.succeed(FetchHttpClient.Fetch, fetchImplementation as typeof fetch))
-      )