@nyc-transit-kit/soda3 0.1.4 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nyc-transit-kit/soda3",
-  "version": "0.1.4",
+  "version": "0.2.0",
   "license": "MIT",
   "type": "module",
   "sideEffects": false,
@@ -13,7 +13,8 @@
     "./export": "./src/export.ts",
     "./metadata": "./src/metadata.ts",
     "./query": "./src/query.ts",
-    "./soql": "./src/soql.ts"
+    "./soql": "./src/soql.ts",
+    "./transport": "./src/transport.ts"
   },
   "types": "./src/index.ts",
   "files": [
@@ -26,7 +27,7 @@
     "test": "bun test ./test"
   },
   "dependencies": {
-    "@nyc-transit-kit/contracts": "0.1.4",
+    "@nyc-transit-kit/contracts": "0.2.0",
     "effect": "4.0.0-beta.92"
   },
   "publishConfig": {

package/src/catalog.ts

@@ -1,10 +1,15 @@
 import type { Soda3CatalogSearchRequestInput } 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 { buildCatalogSearchUrl } from "./endpoints"
-import { decodeCatalogSearchResponse, decodeJson } from "./internal/responses"
-import { Soda3ClientConfig } from "./internal/services"
-import { addHeaders, executeRequest, requestWithPolicy } from "./internal/transport"
+import {
+  addHeaders,
+  decodeCatalogSearchResponse,
+  decodeJson,
+  executeRequest,
+  requestWithPolicy
+} from "./internal/transport"
 
 export { buildCatalogSearchUrl } from "./endpoints"
 export type { Soda3CatalogSearchRequestInput }

package/src/client.ts

@@ -1,17 +1,44 @@
+import * as Context from "effect/Context"
+import * as Layer from "effect/Layer"
+import { type FetchImplementation, fetchHttpClientLayer } from "./transport"
+
 export { catalogSearch } from "./catalog"
 export { exportResponse } from "./export"
-export { Soda3HttpLive } from "./internal/http"
-export type {
-  FetchImplementation,
-  Soda3ClientConfigShape,
-  Soda3LayerOptions
-} from "./internal/services"
-export {
-  Soda3ClientConfig,
-  Soda3Live,
-  soda3ConfigLayer,
-  soda3FetchLayer,
-  soda3Layer
-} from "./internal/services"
 export { fetchDatasetMetadata } from "./metadata"
 export { countRows, queryAllRows, queryRows } from "./query"
+export type { FetchImplementation } from "./transport"
+
+export interface Soda3ClientConfigShape {
+  readonly appToken?: string
+  readonly retryTimes?: number
+  readonly retryDelayMs?: number
+  readonly timeoutMs?: number
+}
+
+export interface Soda3LayerOptions extends Soda3ClientConfigShape {
+  readonly fetch?: FetchImplementation
+}
+
+export class Soda3ClientConfig extends Context.Service<Soda3ClientConfig, Soda3ClientConfigShape>()(
+  "@nyc-transit-kit/soda3/Soda3ClientConfig"
+) {
+  static readonly Default = Layer.succeed(Soda3ClientConfig)({
+    retryTimes: 0
+  })
+}
+
+export const soda3ConfigLayer = (options: Soda3ClientConfigShape = {}) =>
+  Layer.succeed(Soda3ClientConfig)({
+    retryTimes: options.retryTimes ?? 0,
+    ...(options.appToken === undefined ? {} : { appToken: options.appToken }),
+    ...(options.retryDelayMs === undefined ? {} : { retryDelayMs: options.retryDelayMs }),
+    ...(options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs })
+  })
+
+export const Soda3HttpLive = fetchHttpClientLayer()
+export const soda3FetchLayer = fetchHttpClientLayer
+
+export const soda3Layer = (options: Soda3LayerOptions = {}) =>
+  Layer.mergeAll(soda3ConfigLayer(options), soda3FetchLayer(options.fetch))
+
+export const Soda3Live = soda3Layer()

package/src/endpoints.ts

@@ -7,48 +7,15 @@ import {
   type Soda3QueryRequestInput
 } 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 socrataApiVersion = "v3"
 export const defaultSocrataProtocol = "https"
 export const discoveryApiHost = "api.us.socrata.com"
 
-const decodeQueryRequest = (input: unknown) =>
-  Schema.decodeUnknownEffect(Soda3QueryRequest)(input).pipe(
-    Effect.catchTag("SchemaError", (error) =>
-      Effect.fail(
-        InvalidInputError.make({
-          operation: "query",
-          message: error.message
-        })
-      )
-    )
-  )
-
-const decodeExportRequest = (input: unknown) =>
-  Schema.decodeUnknownEffect(Soda3ExportRequest)(input).pipe(
-    Effect.catchTag("SchemaError", (error) =>
-      Effect.fail(
-        InvalidInputError.make({
-          operation: "export",
-          message: error.message
-        })
-      )
-    )
-  )
-
-const decodeCatalogSearchRequest = (input: unknown) =>
-  Schema.decodeUnknownEffect(Soda3CatalogSearchRequest)(input).pipe(
-    Effect.catchTag("SchemaError", (error) =>
-      Effect.fail(
-        InvalidInputError.make({
-          operation: "catalog",
-          message: error.message
-        })
-      )
-    )
-  )
+const decodeQueryRequest = decodeInput("query", Soda3QueryRequest)
+const decodeExportRequest = decodeInput("export", Soda3ExportRequest)
+const decodeCatalogSearchRequest = decodeInput("catalog", Soda3CatalogSearchRequest)
 
 const viewUrl = (domain: string, datasetId: string, suffix: string) => {
   const url = new URL(`${defaultSocrataProtocol}://${domain}`)

package/src/export.ts

@@ -1,12 +1,17 @@
 import type { Soda3ExportRequestInput } 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 { buildExportUrl, decodeSoda3ExportRequest } from "./endpoints"
 import { InvalidInputError } from "./errors"
-import { rangeHeader, toExportBody } from "./internal/bodies"
-import { toWebResponse } from "./internal/http"
-import { Soda3ClientConfig } from "./internal/services"
-import { addHeaders, executeRequest, requestWithPolicy } from "./internal/transport"
+import {
+  addHeaders,
+  executeRequest,
+  rangeHeader,
+  requestWithPolicy,
+  toExportBody,
+  toWebResponse
+} from "./internal/transport"
 
 export type { Soda3ExportRequestInput }
 

package/src/index.ts

@@ -59,3 +59,15 @@ export {
   soqlTimestampRange,
   soqlYearMonthRange
 } from "./soql"
+export type { RequestPolicyConfig } from "./transport"
+export {
+  contentLengthOf,
+  fetchHttpClientLayer,
+  httpFailureInfo,
+  httpStatusText,
+  isOkStatus,
+  redactedUrl,
+  retryableStatus,
+  toWebResponse,
+  withRequestPolicy
+} from "./transport"

package/src/internal/decode.ts

@@ -0,0 +1,12 @@
+import * as Effect from "effect/Effect"
+import * as Schema from "effect/Schema"
+import { InvalidInputError } from "../errors"
+
+export const decodeInput =
+  <S extends Schema.Top>(operation: string, schema: S) =>
+  (input: unknown) =>
+    Schema.decodeUnknownEffect(schema)(input).pipe(
+      Effect.catchTag("SchemaError", (error) =>
+        Effect.fail(InvalidInputError.make({ operation, message: error.message }))
+      )
+    )

package/src/internal/transport.ts

@@ -1,17 +1,39 @@
-import * as Duration from "effect/Duration"
+import {
+  Soda3CatalogSearchResponse,
+  type Soda3ExportRequest,
+  type Soda3QueryRequest,
+  Soda3QueryResponse,
+  Soda3Row
+} from "@nyc-transit-kit/contracts/soda3"
 import * as Effect from "effect/Effect"
-import * as Schedule from "effect/Schedule"
+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 { mapHttpClientError, retryableStatus } from "./http"
-import { Soda3ClientConfig, type Soda3ClientConfigShape } from "./services"
+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",
@@ -20,20 +42,83 @@ export const addHeaders = (config: Soda3ClientConfigShape) => ({
     : {})
 })
 
-export { retryableStatus }
-
-const retryPolicy = (retryTimes: number, retryDelayMs: number | undefined) =>
-  retryDelayMs === undefined || retryDelayMs <= 0
-    ? {
-        times: retryTimes,
-        while: isRetryableProviderError
-      }
-    : {
-        schedule: Schedule.exponential(Duration.millis(retryDelayMs)).pipe(
-          Schedule.both(Schedule.recurs(retryTimes))
+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
+          })
         ),
-        while: isRetryableProviderError
-      }
+        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,
@@ -41,52 +126,29 @@ export const requestWithPolicy = <A>(
 ) =>
   Effect.gen(function* () {
     const config = yield* Soda3ClientConfig
-    const retryTimes = config.retryTimes ?? 0
-    const retried =
-      retryTimes > 0
-        ? effect.pipe(
-            Effect.retry(retryPolicy(retryTimes, config.retryDelayMs)),
-            Effect.catchIf(isRetryableProviderError, (error) =>
-              Effect.fail(
-                RetryExhaustedError.make({
-                  operation,
-                  attempts: retryTimes + 1,
-                  message: `Retry attempts exhausted after provider status ${error.status}`
-                })
-              )
-            )
-          )
-        : effect
-
-    const timeoutMs = config.timeoutMs
-    const timed =
-      timeoutMs === undefined
-        ? retried
-        : retried.pipe(
-            Effect.timeoutOrElse({
-              duration: timeoutMs,
-              orElse: () =>
-                Effect.fail(
-                  TimeoutError.make({
-                    operation,
-                    timeoutMs
-                  })
-                )
-            })
-          )
-
-    return yield* timed
+    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
+        })
+    })
   })
 
-const httpStatusText = (status: number) => `HTTP ${status}`
-
 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 (response.status < 200 || response.status >= 300) {
+    if (!isOkStatus(response.status)) {
       return yield* ProviderHttpError.make({
         operation,
         status: response.status,

package/src/metadata.ts

@@ -4,23 +4,13 @@ import {
   type Soda3DatasetMetadataRequestInput
 } from "@nyc-transit-kit/contracts/soda3"
 import * as Effect from "effect/Effect"
-import * as Schema from "effect/Schema"
 import { catalogSearch } from "./catalog"
-import { InvalidInputError, ProviderContractError } from "./errors"
+import { ProviderContractError } from "./errors"
+import { decodeInput } from "./internal/decode"
 
 export type { Soda3DatasetMetadataRequestInput }
 
-const decodeDatasetMetadataRequest = (input: unknown) =>
-  Schema.decodeUnknownEffect(Soda3DatasetMetadataRequest)(input).pipe(
-    Effect.catchTag("SchemaError", (error) =>
-      Effect.fail(
-        InvalidInputError.make({
-          operation: "metadata",
-          message: error.message
-        })
-      )
-    )
-  )
+const decodeDatasetMetadataRequest = decodeInput("metadata", Soda3DatasetMetadataRequest)
 
 const matchingResult = (results: ReadonlyArray<Soda3CatalogResultFragment>, datasetId: string) =>
   results.find((result) => String(result.resource.id) === datasetId)

package/src/query.ts

@@ -4,14 +4,19 @@ import {
   type Soda3Row
 } from "@nyc-transit-kit/contracts/soda3"
 import * as Effect from "effect/Effect"
-import * as Schema from "effect/Schema"
 import * as HttpClientRequest from "effect/unstable/http/HttpClientRequest"
+import { Soda3ClientConfig } from "./client"
 import { buildQueryUrl, decodeSoda3QueryRequest } from "./endpoints"
 import { InvalidInputError, ProviderContractError } from "./errors"
-import { toQueryBody } from "./internal/bodies"
-import { decodeJson, decodeQueryResponse } from "./internal/responses"
-import { Soda3ClientConfig } from "./internal/services"
-import { addHeaders, executeRequest, requestWithPolicy } from "./internal/transport"
+import { decodeInput } from "./internal/decode"
+import {
+  addHeaders,
+  decodeJson,
+  decodeQueryResponse,
+  executeRequest,
+  requestWithPolicy,
+  toQueryBody
+} from "./internal/transport"
 
 export type { Soda3QueryRequestInput }
 
@@ -28,14 +33,15 @@ export type Soda3CountRowsInput = {
 }
 
 const decodeHelperPositiveInteger = (name: string, value: number) =>
-  Schema.decodeUnknownEffect(PositiveInteger)(value).pipe(
-    Effect.catchTag("SchemaError", (error) =>
-      Effect.fail(
-        InvalidInputError.make({
-          operation: "query",
-          message: `Invalid ${name}: ${error.message}`
-        })
-      )
+  decodeInput(
+    "query",
+    PositiveInteger
+  )(value).pipe(
+    Effect.mapError((error) =>
+      InvalidInputError.make({
+        operation: "query",
+        message: `Invalid ${name}: ${error.message}`
+      })
     )
   )
 

package/src/soql.ts

@@ -3,351 +3,212 @@ 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
-  readonly parameters?: SoqlParameters
-}
-
-export type SocrataTimestampWindow = {
-  readonly start: string
-  readonly end: string
-}
-
-export type SocrataYearMonth = {
-  readonly year: number
-  readonly month: number
-}
-
-const soqlIdentifierPattern = /^[A-Za-z_][A-Za-z0-9_]*$/
-const soqlParameterNamePattern = /^[A-Za-z_][A-Za-z0-9_]*$/
-const isoDatePartsPattern = /^(\d{4})-(\d{2})-(\d{2})$/
-
-const SoqlIdentifier = Schema.String.pipe(
-  Schema.check(
-    Schema.isPattern(soqlIdentifierPattern, {
-      message: "Expected a SoQL identifier such as route_id"
-    })
-  )
+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 = Schema.String.pipe(
-  Schema.check(
-    Schema.isPattern(soqlParameterNamePattern, {
-      message: "Expected a SoQL parameter name such as route"
-    })
-  )
+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 SocrataYear = Schema.Int.pipe(
-  Schema.check(Schema.isGreaterThanOrEqualTo(1900)),
-  Schema.check(Schema.isLessThanOrEqualTo(9999))
-)
-
-const SocrataMonth = Schema.Int.pipe(
-  Schema.check(Schema.isGreaterThanOrEqualTo(1)),
-  Schema.check(Schema.isLessThanOrEqualTo(12))
-)
-
-const SocrataYearMonthSchema = Schema.Struct({
-  year: SocrataYear,
-  month: SocrataMonth
-})
-
+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 decodeQueryInput =
-  <S extends Schema.Top>(schema: S) =>
-  (input: unknown) =>
-    Schema.decodeUnknownEffect(schema)(input).pipe(
-      Effect.catchTag("SchemaError", (error) => Effect.fail(invalidQueryInput(error.message)))
-    )
-
-const decodeLimit = decodeQueryInput(PositiveInteger)
-const decodeIdentifier = decodeQueryInput(SoqlIdentifier)
-const decodeParameterName = decodeQueryInput(SoqlParameterName)
-const decodeSortDirection = decodeQueryInput(SoqlSortDirection)
-const decodeIsoDate = decodeQueryInput(IsoDate)
-const decodeYear = decodeQueryInput(SocrataYear)
-const decodeMonth = decodeQueryInput(SocrataMonth)
-const decodeYearMonth = decodeQueryInput(SocrataYearMonthSchema)
-
-const withParameters = (
-  text: string,
-  parameters: Readonly<Record<string, unknown>>
-): SoqlFragment => ({
-  text,
-  parameters
-})
-
-const withoutParameters = (text: string): SoqlFragment => ({
-  text
-})
-
-const mergeParameters = (fragments: ReadonlyArray<SoqlFragment>) =>
-  Effect.gen(function* () {
-    const parameters: Record<string, unknown> = {}
-
-    for (const fragment of fragments) {
-      for (const [key, value] of Object.entries(fragment.parameters ?? {})) {
-        if (Object.hasOwn(parameters, key)) {
-          return yield* invalidQueryInput(`Duplicate SoQL parameter name: ${key}`)
-        }
-        parameters[key] = value
+  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 Object.keys(parameters).length === 0 ? undefined : parameters
-  })
-
-const pad2 = (value: number) => value.toString().padStart(2, "0")
-
+  }
+  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) =>
-  `${year.toString().padStart(4, "0")}-${pad2(month)}-${pad2(day)}T00:00:00`
-
-const dateParts = (value: string) =>
-  Effect.gen(function* () {
-    const match = isoDatePartsPattern.exec(value)
-    if (match === null) {
-      return yield* invalidQueryInput("Expected an ISO calendar date in YYYY-MM-DD format")
-    }
-
-    const yearText = match[1]
-    const monthText = match[2]
-    const dayText = match[3]
-    if (yearText === undefined || monthText === undefined || dayText === undefined) {
-      return yield* invalidQueryInput("Expected an ISO calendar date in YYYY-MM-DD format")
-    }
-
-    return {
-      year: Number(yearText),
-      month: Number(monthText),
-      day: Number(dayText)
-    }
-  })
-
-const utcTimestampFromDate = (date: Date) =>
-  Effect.gen(function* () {
-    if (Number.isNaN(date.getTime())) {
-      return yield* invalidQueryInput("Expected a valid Date")
-    }
-
-    return timestampFromParts(date.getUTCFullYear(), date.getUTCMonth() + 1, date.getUTCDate())
-  })
-
-const epochDay = (value: string) =>
-  Effect.gen(function* () {
-    const parts = yield* dateParts(value)
-    return Date.UTC(parts.year, parts.month - 1, parts.day)
-  })
-
-export const soqlLimit = Effect.fn("Soda3.soqlLimit")(function* (query: string, limit: unknown) {
-  const decodedLimit = yield* decodeLimit(limit)
-  return `${query} LIMIT ${decodedLimit}`
+  `${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 = Effect.fn("Soda3.soqlIdentifier")(function* (input: unknown) {
+export const soqlIdentifier = fn("Soda3.soqlIdentifier")(function* (input: unknown) {
   return yield* decodeIdentifier(input)
 })
-
-export const soqlParameterName = Effect.fn("Soda3.soqlParameterName")(function* (input: unknown) {
+export const soqlParameterName = fn("Soda3.soqlParameterName")(function* (input: unknown) {
   return yield* decodeParameterName(input)
 })
-
-export const soqlParameter = Effect.fn("Soda3.soqlParameter")(function* (
-  name: unknown,
-  value: unknown
-) {
-  const decodedName = yield* decodeParameterName(name)
-  return withParameters(`:${decodedName}`, {
-    [decodedName]: value
-  })
+export const soqlParameter = fn("Soda3.soqlParameter")(function* (name: unknown, value: unknown) {
+  const key = yield* decodeParameterName(name)
+  return fragment(`:${key}`, { [key]: value })
 })
-
-export const soqlEq = Effect.fn("Soda3.soqlEq")(function* (
+export const soqlEq = fn("Soda3.soqlEq")(function* (
   column: unknown,
   parameterName: unknown,
   value: unknown
 ) {
-  const decodedColumn = yield* decodeIdentifier(column)
-  const decodedParameterName = yield* decodeParameterName(parameterName)
-
-  return withParameters(`${decodedColumn} = :${decodedParameterName}`, {
-    [decodedParameterName]: value
-  })
+  const col = yield* decodeIdentifier(column)
+  const key = yield* decodeParameterName(parameterName)
+  return fragment(`${col} = :${key}`, { [key]: value })
 })
-
-export const soqlIn = Effect.fn("Soda3.soqlIn")(function* (
+export const soqlIn = fn("Soda3.soqlIn")(function* (
   column: unknown,
   parameterBaseName: unknown,
   values: ReadonlyArray<unknown>
 ) {
-  const decodedColumn = yield* decodeIdentifier(column)
-  const decodedParameterBaseName = yield* decodeParameterName(parameterBaseName)
-
   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 parameterName = `${decodedParameterBaseName}_${index + 1}`
-    parameters[parameterName] = values[index]
-    placeholders.push(`:${parameterName}`)
+    const key = `${base}_${index + 1}`
+    parameters[key] = values[index]
+    placeholders.push(`:${key}`)
   }
-
-  return withParameters(`${decodedColumn} IN (${placeholders.join(", ")})`, parameters)
+  return fragment(`${col} IN (${placeholders.join(", ")})`, parameters)
 })
-
-export const soqlIsNotNull = Effect.fn("Soda3.soqlIsNotNull")(function* (column: unknown) {
-  const decodedColumn = yield* decodeIdentifier(column)
-  return withoutParameters(`${decodedColumn} IS NOT NULL`)
+export const soqlIsNotNull = fn("Soda3.soqlIsNotNull")(function* (column: unknown) {
+  return fragment(`${yield* decodeIdentifier(column)} IS NOT NULL`)
 })
-
-export const soqlAnd = Effect.fn("Soda3.soqlAnd")(function* (
-  fragments: ReadonlyArray<SoqlFragment>
-) {
+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")
   }
-
-  const parameters = yield* mergeParameters(fragments)
-  const text = fragments.map((fragment) => `(${fragment.text})`).join(" AND ")
-
-  return parameters === undefined ? withoutParameters(text) : withParameters(text, parameters)
+  return fragment(
+    fragments.map((part) => `(${part.text})`).join(" AND "),
+    yield* mergeParameters(fragments)
+  )
 })
-
-export const soqlOrderBy = Effect.fn("Soda3.soqlOrderBy")(function* (
+export const soqlOrderBy = fn("Soda3.soqlOrderBy")(function* (
   column: unknown,
   direction: unknown = "ASC"
 ) {
-  const decodedColumn = yield* decodeIdentifier(column)
-  const decodedDirection = yield* decodeSortDirection(direction)
-  return withoutParameters(`ORDER BY ${decodedColumn} ${decodedDirection}`)
+  const col = yield* decodeIdentifier(column)
+  return fragment(`ORDER BY ${col} ${yield* decodeSortDirection(direction)}`)
 })
-
-export const socrataTimestamp = Effect.fn("Soda3.socrataTimestamp")(function* (
-  date: string | Date
-) {
+export const socrataTimestamp = fn("Soda3.socrataTimestamp")(function* (date: string | Date) {
   if (date instanceof Date) {
-    return yield* utcTimestampFromDate(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* dateParts(decodedDate)
+  const parts = yield* datePartsOf(decodedDate)
   return timestampFromParts(parts.year, parts.month, parts.day)
 })
-
-export const socrataMonthWindow = Effect.fn("Soda3.socrataMonthWindow")(function* (
+export const socrataMonthWindow = fn("Soda3.socrataMonthWindow")(function* (
   year: unknown,
   month: unknown
 ) {
-  const decodedYear = yield* decodeYear(year)
-  const decodedMonth = yield* decodeMonth(month)
-  const endYear = decodedMonth === 12 ? decodedYear + 1 : decodedYear
-  const endMonth = decodedMonth === 12 ? 1 : decodedMonth + 1
-
+  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(decodedYear, decodedMonth, 1),
+    start: timestampFromParts(y, m, 1),
     end: timestampFromParts(endYear, endMonth, 1)
   }
 })
-
-export const socrataDateWindow = Effect.fn("Soda3.socrataDateWindow")(function* (
+export const socrataDateWindow = fn("Soda3.socrataDateWindow")(function* (
   startDate: unknown,
   endDate: unknown
 ) {
-  const decodedStartDate = yield* decodeIsoDate(startDate)
-  const decodedEndDate = yield* decodeIsoDate(endDate)
-  const startEpochDay = yield* epochDay(decodedStartDate)
-  const endEpochDay = yield* epochDay(decodedEndDate)
-
-  if (startEpochDay >= endEpochDay) {
+  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: yield* socrataTimestamp(decodedStartDate),
-    end: yield* socrataTimestamp(decodedEndDate)
+    start: timestampFromParts(start.year, start.month, start.day),
+    end: timestampFromParts(end.year, end.month, end.day)
   }
 })
-
-export const soqlTimestampRange = Effect.fn("Soda3.soqlTimestampRange")(function* (
+export const soqlTimestampRange = fn("Soda3.soqlTimestampRange")(function* (
   column: unknown,
   startParameterName: unknown,
   endParameterName: unknown,
-  window: SocrataTimestampWindow
+  w: SocrataTimestampWindow
 ) {
-  const decodedColumn = yield* decodeIdentifier(column)
-  const decodedStartParameterName = yield* decodeParameterName(startParameterName)
-  const decodedEndParameterName = yield* decodeParameterName(endParameterName)
-
-  if (decodedStartParameterName === decodedEndParameterName) {
-    return yield* invalidQueryInput(`Duplicate SoQL parameter name: ${decodedStartParameterName}`)
+  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 withParameters(
-    `${decodedColumn} >= :${decodedStartParameterName} AND ${decodedColumn} < :${decodedEndParameterName}`,
-    {
-      [decodedStartParameterName]: window.start,
-      [decodedEndParameterName]: window.end
-    }
-  )
+  return fragment(`${col} >= :${s} AND ${col} < :${e}`, { [s]: w.start, [e]: w.end })
 })
-
-export const soqlMonthWindow = Effect.fn("Soda3.soqlMonthWindow")(function* (
+export const soqlMonthWindow = fn("Soda3.soqlMonthWindow")(function* (
   column: unknown,
   year: unknown,
   month: unknown,
   parameterBaseName: unknown
 ) {
-  const decodedParameterBaseName = yield* decodeParameterName(parameterBaseName)
+  const base = yield* decodeParameterName(parameterBaseName)
   const window = yield* socrataMonthWindow(year, month)
-  return yield* soqlTimestampRange(
-    column,
-    `${decodedParameterBaseName}_start`,
-    `${decodedParameterBaseName}_end`,
-    window
-  )
+  return yield* soqlTimestampRange(column, `${base}_start`, `${base}_end`, window)
 })
-
-export const soqlYearMonthRange = Effect.fn("Soda3.soqlYearMonthRange")(function* (
+export const soqlYearMonthRange = fn("Soda3.soqlYearMonthRange")(function* (
   yearColumn: unknown,
   monthColumn: unknown,
   start: unknown,
   end: unknown
 ) {
-  const decodedYearColumn = yield* decodeIdentifier(yearColumn)
-  const decodedMonthColumn = yield* decodeIdentifier(monthColumn)
-  const decodedStart = yield* decodeYearMonth(start)
-  const decodedEnd = yield* decodeYearMonth(end)
-  const startOrder = decodedStart.year * 12 + decodedStart.month
-  const endOrder = decodedEnd.year * 12 + decodedEnd.month
-
+  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 withParameters(
-    `(${decodedYearColumn} > :start_year OR (${decodedYearColumn} = :start_year AND ${decodedMonthColumn} >= :start_month)) AND (${decodedYearColumn} < :end_year OR (${decodedYearColumn} = :end_year AND ${decodedMonthColumn} <= :end_month))`,
-    {
-      start_year: decodedStart.year,
-      start_month: decodedStart.month,
-      end_year: decodedEnd.year,
-      end_month: decodedEnd.month
-    }
+  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

@@ -0,0 +1,145 @@
+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))
+      )

package/src/internal/bodies.ts

@@ -1,23 +0,0 @@
-import type { Soda3ExportRequest, Soda3QueryRequest } from "@nyc-transit-kit/contracts/soda3"
-
-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 ?? ""}`

package/src/internal/http.ts

@@ -1,42 +0,0 @@
-import * as Effect from "effect/Effect"
-import * as Stream from "effect/Stream"
-import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient"
-import type * as HttpClientError from "effect/unstable/http/HttpClientError"
-import type * as HttpClientResponse from "effect/unstable/http/HttpClientResponse"
-import { ProviderHttpError } from "../errors"
-
-export const Soda3HttpLive = FetchHttpClient.layer
-
-export const retryableStatus = (status: number) => status === 429 || status >= 500
-
-const httpStatusText = (status: number) => `HTTP ${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 mapHttpClientError = (operation: string, error: HttpClientError.HttpClientError) => {
-  const response = error.response
-
-  if (response !== undefined) {
-    return ProviderHttpError.make({
-      operation,
-      status: response.status,
-      statusText: httpStatusText(response.status),
-      retryable: retryableStatus(response.status)
-    })
-  }
-
-  return ProviderHttpError.make({
-    operation,
-    status: 0,
-    statusText: error.message,
-    retryable: true
-  })
-}

package/src/internal/responses.ts

@@ -1,56 +0,0 @@
-import {
-  Soda3CatalogSearchResponse,
-  Soda3QueryResponse,
-  Soda3Row
-} from "@nyc-transit-kit/contracts/soda3"
-import * as Effect from "effect/Effect"
-import * as Schema from "effect/Schema"
-import type * as HttpClientResponse from "effect/unstable/http/HttpClientResponse"
-import { ProviderContractError } from "../errors"
-
-const providerRows = Schema.Array(Soda3Row)
-
-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) =>
-  Schema.decodeUnknownEffect(Soda3QueryResponse)(input).pipe(
-    Effect.catchTag("SchemaError", (error) =>
-      Schema.decodeUnknownEffect(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) =>
-  Schema.decodeUnknownEffect(Soda3CatalogSearchResponse)(input).pipe(
-    Effect.catchTag("SchemaError", (error) =>
-      Effect.fail(
-        ProviderContractError.make({
-          operation: "catalog",
-          message: error.message
-        })
-      )
-    )
-  )

package/src/internal/services.ts

@@ -1,48 +0,0 @@
-import * as Context from "effect/Context"
-import * as Layer from "effect/Layer"
-import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient"
-import { Soda3HttpLive } from "./http"
-
-export interface Soda3ClientConfigShape {
-  readonly appToken?: string
-  readonly retryTimes?: number
-  readonly retryDelayMs?: number
-  readonly timeoutMs?: number
-}
-
-export type FetchImplementation = (
-  input: string | URL | globalThis.Request,
-  init?: globalThis.RequestInit
-) => Promise<globalThis.Response>
-
-export interface Soda3LayerOptions extends Soda3ClientConfigShape {
-  readonly fetch?: FetchImplementation
-}
-
-export class Soda3ClientConfig extends Context.Service<Soda3ClientConfig, Soda3ClientConfigShape>()(
-  "@nyc-transit-kit/soda3/Soda3ClientConfig"
-) {
-  static readonly Default = Layer.succeed(Soda3ClientConfig)({
-    retryTimes: 0
-  })
-}
-
-export const soda3ConfigLayer = (options: Soda3ClientConfigShape = {}) =>
-  Layer.succeed(Soda3ClientConfig)({
-    retryTimes: options.retryTimes ?? 0,
-    ...(options.appToken === undefined ? {} : { appToken: options.appToken }),
-    ...(options.retryDelayMs === undefined ? {} : { retryDelayMs: options.retryDelayMs }),
-    ...(options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs })
-  })
-
-export const soda3FetchLayer = (fetchImplementation?: FetchImplementation) =>
-  fetchImplementation === undefined
-    ? Soda3HttpLive
-    : FetchHttpClient.layer.pipe(
-        Layer.provide(Layer.succeed(FetchHttpClient.Fetch, fetchImplementation as typeof fetch))
-      )
-
-export const soda3Layer = (options: Soda3LayerOptions = {}) =>
-  Layer.mergeAll(soda3ConfigLayer(options), soda3FetchLayer(options.fetch))
-
-export const Soda3Live = soda3Layer()