@nyc-transit-kit/soda3 0.1.4 → 0.3.0

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()

package/src/internal/transport.ts

@@ -1,99 +0,0 @@
-import * as Duration from "effect/Duration"
-import * as Effect from "effect/Effect"
-import * as Schedule from "effect/Schedule"
-import * as HttpClient from "effect/unstable/http/HttpClient"
-import type * as HttpClientRequest from "effect/unstable/http/HttpClientRequest"
-import type { Soda3ClientError } from "../errors"
-import {
-  isRetryableProviderError,
-  ProviderHttpError,
-  RetryExhaustedError,
-  TimeoutError
-} from "../errors"
-import { mapHttpClientError, retryableStatus } from "./http"
-import { Soda3ClientConfig, type Soda3ClientConfigShape } from "./services"
-
-export const addHeaders = (config: Soda3ClientConfigShape) => ({
-  accept: "application/json",
-  ...(config.appToken !== undefined && config.appToken.length > 0
-    ? { "X-App-Token": config.appToken }
-    : {})
-})
-
-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))
-        ),
-        while: isRetryableProviderError
-      }
-
-export const requestWithPolicy = <A>(
-  operation: string,
-  effect: Effect.Effect<A, Soda3ClientError, HttpClient.HttpClient | Soda3ClientConfig>
-) =>
-  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
-  })
-
-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) {
-      return yield* ProviderHttpError.make({
-        operation,
-        status: response.status,
-        statusText: httpStatusText(response.status),
-        retryable: retryableStatus(response.status)
-      })
-    }
-
-    return response
-  })

package/src/metadata.ts

@@ -1,47 +0,0 @@
-import {
-  type Soda3CatalogResultFragment,
-  Soda3DatasetMetadataRequest,
-  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"
-
-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 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,132 +0,0 @@
-import {
-  PositiveInteger,
-  type Soda3QueryRequestInput,
-  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 { 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"
-
-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) =>
-  Schema.decodeUnknownEffect(PositiveInteger)(value).pipe(
-    Effect.catchTag("SchemaError", (error) =>
-      Effect.fail(
-        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,353 +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"
-
-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"
-    })
-  )
-)
-
-const SoqlParameterName = Schema.String.pipe(
-  Schema.check(
-    Schema.isPattern(soqlParameterNamePattern, {
-      message: "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 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
-      }
-    }
-
-    return Object.keys(parameters).length === 0 ? undefined : parameters
-  })
-
-const pad2 = (value: number) => value.toString().padStart(2, "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}`
-})
-
-export const soqlIdentifier = Effect.fn("Soda3.soqlIdentifier")(function* (input: unknown) {
-  return yield* decodeIdentifier(input)
-})
-
-export const soqlParameterName = Effect.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 soqlEq = Effect.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
-  })
-})
-
-export const soqlIn = Effect.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 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}`)
-  }
-
-  return withParameters(`${decodedColumn} 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 soqlAnd = Effect.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)
-})
-
-export const soqlOrderBy = Effect.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}`)
-})
-
-export const socrataTimestamp = Effect.fn("Soda3.socrataTimestamp")(function* (
-  date: string | Date
-) {
-  if (date instanceof Date) {
-    return yield* utcTimestampFromDate(date)
-  }
-
-  const decodedDate = yield* decodeIsoDate(date)
-  const parts = yield* dateParts(decodedDate)
-  return timestampFromParts(parts.year, parts.month, parts.day)
-})
-
-export const socrataMonthWindow = Effect.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
-
-  return {
-    start: timestampFromParts(decodedYear, decodedMonth, 1),
-    end: timestampFromParts(endYear, endMonth, 1)
-  }
-})
-
-export const socrataDateWindow = Effect.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) {
-    return yield* invalidQueryInput("Socrata date windows require startDate before endDate")
-  }
-
-  return {
-    start: yield* socrataTimestamp(decodedStartDate),
-    end: yield* socrataTimestamp(decodedEndDate)
-  }
-})
-
-export const soqlTimestampRange = Effect.fn("Soda3.soqlTimestampRange")(function* (
-  column: unknown,
-  startParameterName: unknown,
-  endParameterName: unknown,
-  window: 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}`)
-  }
-
-  return withParameters(
-    `${decodedColumn} >= :${decodedStartParameterName} AND ${decodedColumn} < :${decodedEndParameterName}`,
-    {
-      [decodedStartParameterName]: window.start,
-      [decodedEndParameterName]: window.end
-    }
-  )
-})
-
-export const soqlMonthWindow = Effect.fn("Soda3.soqlMonthWindow")(function* (
-  column: unknown,
-  year: unknown,
-  month: unknown,
-  parameterBaseName: unknown
-) {
-  const decodedParameterBaseName = yield* decodeParameterName(parameterBaseName)
-  const window = yield* socrataMonthWindow(year, month)
-  return yield* soqlTimestampRange(
-    column,
-    `${decodedParameterBaseName}_start`,
-    `${decodedParameterBaseName}_end`,
-    window
-  )
-})
-
-export const soqlYearMonthRange = Effect.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
-
-  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
-    }
-  )
-})