@nyc-transit-kit/cli 0.1.4 → 0.2.0

package/src/commands/nyc-dot.ts

@@ -1,209 +1,66 @@
-import type { Soda3ExportFormat } from "@nyc-transit-kit/contracts/soda3"
-import { exportNycDotDataset, queryNycDotDataset } from "@nyc-transit-kit/nyc-dot/client"
 import {
+  exportNycDotDataset,
   findNycDotDataset,
   nycDotDatasets,
-  nycDotOpenDataDomain
+  nycDotOpenDataDomain,
+  queryNycDotDataset
 } from "@nyc-transit-kit/nyc-dot/datasets"
-import * as Effect from "effect/Effect"
 import * as Command from "effect/unstable/cli/Command"
-import * as Flag from "effect/unstable/cli/Flag"
-import { failCommand, runEffect, soqlFromSelect, writeSuccess } from "./shared"
-import { writeResponseToFile, writeSoda3ExportDryRun, writeSoda3QueryDryRun } from "./soda3-shared"
-import { CliCommandContext } from "./types"
-
-export const nycDotCommandPaths: ReadonlyArray<ReadonlyArray<string>> = [
-  ["nyc-dot", "dataset", "list"],
-  ["nyc-dot", "dataset", "info"],
-  ["nyc-dot", "dataset", "query"],
-  ["nyc-dot", "dataset", "export"]
-]
-
-export const handleNycDotList = () =>
-  Effect.gen(function* () {
-    const context = yield* CliCommandContext
-    return yield* writeSuccess(context, "nyc-dot", {
-      datasets: nycDotDatasets
-    })
-  })
-
-export const handleNycDotInfo = (config: { readonly name: string }) =>
-  Effect.gen(function* () {
-    const context = yield* CliCommandContext
-    const descriptor = findNycDotDataset(config.name)
-
-    if (descriptor === undefined) {
-      return yield* failCommand(
-        context,
-        "nyc-dot",
-        "unsupported-dataset",
-        `Unsupported NYC DOT dataset: ${config.name}`,
-        ["nyc-dot", "dataset", "info"]
-      )
-    }
-
-    return yield* writeSuccess(context, "nyc-dot", descriptor)
-  })
-
-export const handleNycDotQuery = (config: {
-  readonly name: string
-  readonly select: string
-  readonly dryRun: boolean
-}) =>
-  Effect.gen(function* () {
-    const context = yield* CliCommandContext
-    const tokens = ["nyc-dot", "dataset", "query"]
-    const descriptor = findNycDotDataset(config.name)
-
-    if (descriptor === undefined) {
-      return yield* failCommand(
-        context,
-        "nyc-dot",
-        "unsupported-dataset",
-        `Unsupported NYC DOT dataset: ${config.name}`,
-        tokens
-      )
-    }
-
-    const request = {
-      name: config.name,
-      query: soqlFromSelect(config.select)
-    }
-
-    if (config.dryRun) {
-      return yield* writeSoda3QueryDryRun({
-        context,
-        apiFamily: "nyc-dot",
-        tokens,
-        domain: nycDotOpenDataDomain,
-        datasetId: String(descriptor.id),
-        query: request.query,
-        extra: {
-          dataset: descriptor
+import { makeDatasetCommands } from "./shared"
+
+const unsupportedDataset = (name: string) => ({
+  code: "unsupported-dataset",
+  message: `Unsupported NYC DOT dataset: ${name}`
+})
+
+const resolveNycDotDataset = (name: string) => {
+  const descriptor = findNycDotDataset(name)
+  return descriptor === undefined
+    ? { failure: unsupportedDataset(name) }
+    : {
+        payload: {
+          datasetId: String(descriptor.id),
+          extra: {
+            dataset: descriptor
+          }
         }
-      })
-    }
-
-    return yield* runEffect(
-      context,
-      "nyc-dot",
-      tokens,
-      queryNycDotDataset(request).pipe(Effect.provide(context.runtime.soda3Layer))
-    )
-  })
-
-export const handleNycDotExport = (config: {
-  readonly name: string
-  readonly format: Soda3ExportFormat
-  readonly output: string
-  readonly dryRun: boolean
-}) =>
-  Effect.gen(function* () {
-    const context = yield* CliCommandContext
-    const tokens = ["nyc-dot", "dataset", "export"]
-    const descriptor = findNycDotDataset(config.name)
-
-    if (descriptor === undefined) {
-      return yield* failCommand(
-        context,
-        "nyc-dot",
-        "unsupported-dataset",
-        `Unsupported NYC DOT dataset: ${config.name}`,
-        tokens
-      )
-    }
-
-    const request = {
-      name: config.name,
-      format: config.format
-    }
-
-    if (config.dryRun) {
-      return yield* writeSoda3ExportDryRun({
-        context,
-        apiFamily: "nyc-dot",
-        tokens,
-        domain: nycDotOpenDataDomain,
-        datasetId: String(descriptor.id),
-        format: request.format,
-        output: config.output,
-        extra: {
-          dataset: descriptor
-        }
-      })
-    }
-
-    return yield* runEffect(
-      context,
-      "nyc-dot",
-      tokens,
-      Effect.gen(function* () {
-        const response = yield* exportNycDotDataset(request).pipe(
-          Effect.provide(context.runtime.soda3Layer)
-        )
-        return yield* writeResponseToFile(config.output, response)
-      })
-    )
-  })
-
-const nycDotDatasetListCommand = Command.make("list", {}, handleNycDotList).pipe(
-  Command.withShortDescription("List curated NYC DOT dataset descriptors.")
-)
-
-const nycDotDatasetInfoCommand = Command.make(
-  "info",
-  {
-    name: Flag.string("name").pipe(
-      Flag.withDescription("Known NYC DOT dataset name, such as traffic-speeds.")
-    )
-  },
-  handleNycDotInfo
-).pipe(Command.withShortDescription("Show NYC DOT dataset metadata."))
-
-const nycDotDatasetQueryCommand = Command.make(
-  "query",
-  {
-    name: Flag.string("name").pipe(
-      Flag.withDescription("Known NYC DOT dataset name, such as traffic-speeds.")
-    ),
-    select: Flag.string("select").pipe(
-      Flag.withDescription("SoQL select expression or full SELECT query.")
-    ),
-    dryRun: Flag.boolean("dry-run").pipe(
-      Flag.withDescription("Print the planned request without contacting the provider.")
-    )
+      }
+}
+
+const nycDotDatasetCommands = makeDatasetCommands({
+  family: "nyc-dot",
+  tokens: ["nyc-dot", "dataset"],
+  idConfigKey: "name",
+  idFlagName: "name",
+  idFlagDescription: "Known NYC DOT dataset name, such as traffic-speeds.",
+  domain: nycDotOpenDataDomain,
+  listShortDescription: "List curated NYC DOT dataset descriptors.",
+  infoShortDescription: "Show NYC DOT dataset metadata.",
+  queryShortDescription: "Run a NYC DOT SODA3 query.",
+  exportShortDescription: "Export a NYC DOT dataset.",
+  listPayload: () => ({ datasets: nycDotDatasets }),
+  infoPayload: (name) => {
+    const descriptor = findNycDotDataset(name)
+    return descriptor === undefined
+      ? { failure: unsupportedDataset(name) }
+      : { payload: descriptor }
   },
-  handleNycDotQuery
-).pipe(Command.withShortDescription("Run a NYC DOT SODA3 query."))
-
-const nycDotDatasetExportCommand = Command.make(
-  "export",
-  {
-    name: Flag.string("name").pipe(
-      Flag.withDescription("Known NYC DOT dataset name, such as traffic-speeds.")
-    ),
-    format: Flag.choice("format", ["csv", "json", "geojson"]).pipe(
-      Flag.withDefault("csv"),
-      Flag.withDescription("Export format. Defaults to csv.")
-    ),
-    output: Flag.string("output").pipe(
-      Flag.withDescription("Destination file path for the downloaded response body.")
-    ),
-    dryRun: Flag.boolean("dry-run").pipe(
-      Flag.withDescription("Print the planned request without contacting the provider.")
-    )
-  },
-  handleNycDotExport
-).pipe(Command.withShortDescription("Export a NYC DOT dataset."))
+  resolveDataset: resolveNycDotDataset,
+  query: ({ id, query }) =>
+    queryNycDotDataset({
+      name: id,
+      query
+    }),
+  exportResponse: ({ id, format }) =>
+    exportNycDotDataset({
+      name: id,
+      format
+    })
+})
 
 const nycDotDatasetCommand = Command.make("dataset").pipe(
   Command.withShortDescription("NYC DOT dataset commands."),
-  Command.withSubcommands([
-    nycDotDatasetListCommand,
-    nycDotDatasetInfoCommand,
-    nycDotDatasetQueryCommand,
-    nycDotDatasetExportCommand
-  ])
+  Command.withSubcommands(nycDotDatasetCommands)
 )
 
 export const nycDotCommand = Command.make("nyc-dot").pipe(

package/src/commands/nyc-open-data.ts

@@ -1,29 +1,20 @@
-import type { Soda3ExportFormat } from "@nyc-transit-kit/contracts/soda3"
-import { searchNycOpenDataCatalog } from "@nyc-transit-kit/nyc-open-data/catalog"
-import { exportNycOpenDataDataset } from "@nyc-transit-kit/nyc-open-data/client"
+import {
+  exportNycOpenDataDataset,
+  queryNycOpenDataDataset,
+  searchNycOpenDataCatalog
+} from "@nyc-transit-kit/nyc-open-data/client"
 import {
   defaultDomain,
   findNycOpenDataDataset,
   knownNycOpenDataDatasets
 } from "@nyc-transit-kit/nyc-open-data/descriptors"
-import { queryNycOpenDataDataset } from "@nyc-transit-kit/nyc-open-data/query"
 import { buildCatalogSearchUrl } from "@nyc-transit-kit/soda3/endpoints"
 import * as Effect from "effect/Effect"
 import * as Command from "effect/unstable/cli/Command"
 import * as Flag from "effect/unstable/cli/Flag"
-import { runEffect, soqlFromSelect, writeSuccess } from "./shared"
-import { writeResponseToFile, writeSoda3ExportDryRun, writeSoda3QueryDryRun } from "./soda3-shared"
-import { CliCommandContext } from "./types"
-
-export const nycOpenDataCommandPaths: ReadonlyArray<ReadonlyArray<string>> = [
-  ["nyc-open-data", "catalog", "search"],
-  ["nyc-open-data", "dataset", "list"],
-  ["nyc-open-data", "dataset", "info"],
-  ["nyc-open-data", "dataset", "query"],
-  ["nyc-open-data", "dataset", "export"]
-]
+import { CliCommandContext, dryRunFlag, makeDatasetCommands, runEffect } from "./shared"
 
-export const handleNycOpenDataCatalogSearch = (config: {
+const handleNycOpenDataCatalogSearch = (config: {
   readonly query: string
   readonly limit: number
   readonly dryRun: boolean
@@ -62,100 +53,50 @@ export const handleNycOpenDataCatalogSearch = (config: {
     )
   })
 
-export const handleNycOpenDataList = () =>
-  Effect.gen(function* () {
-    const context = yield* CliCommandContext
-    return yield* writeSuccess(context, "nyc-open-data", {
-      datasets: knownNycOpenDataDatasets
-    })
-  })
-
-export const handleNycOpenDataInfo = (config: { readonly datasetId: string }) =>
-  Effect.gen(function* () {
-    const context = yield* CliCommandContext
-    const descriptor = findNycOpenDataDataset(config.datasetId)
-
-    return yield* writeSuccess(context, "nyc-open-data", {
-      known: descriptor !== undefined,
-      descriptor:
-        descriptor === undefined
-          ? {
-              id: config.datasetId,
-              domain: defaultDomain,
-              backing: "socrata"
-            }
-          : descriptor
-    })
-  })
-
-export const handleNycOpenDataQuery = (config: {
-  readonly datasetId: string
-  readonly select: string
-  readonly dryRun: boolean
-}) =>
-  Effect.gen(function* () {
-    const context = yield* CliCommandContext
-    const tokens = ["nyc-open-data", "dataset", "query"]
-    const request = {
-      datasetId: config.datasetId,
-      query: soqlFromSelect(config.select)
-    }
-
-    if (config.dryRun) {
-      return yield* writeSoda3QueryDryRun({
-        context,
-        apiFamily: "nyc-open-data",
-        tokens,
-        domain: defaultDomain,
-        ...request
-      })
+const nycOpenDataDatasetCommands = makeDatasetCommands({
+  family: "nyc-open-data",
+  tokens: ["nyc-open-data", "dataset"],
+  idConfigKey: "datasetId",
+  idFlagName: "dataset",
+  idFlagDescription: "NYC Open Data Socrata dataset id.",
+  domain: defaultDomain,
+  listShortDescription: "List curated NYC Open Data descriptors.",
+  infoShortDescription: "Show NYC Open Data dataset metadata.",
+  queryShortDescription: "Run a NYC Open Data SODA3 query.",
+  exportShortDescription: "Export a NYC Open Data dataset.",
+  listPayload: () => ({ datasets: knownNycOpenDataDatasets }),
+  infoPayload: (datasetId) => {
+    const descriptor = findNycOpenDataDataset(datasetId)
+    return {
+      payload: {
+        known: descriptor !== undefined,
+        descriptor:
+          descriptor === undefined
+            ? {
+                id: datasetId,
+                domain: defaultDomain,
+                backing: "socrata"
+              }
+            : descriptor
+      }
     }
-
-    return yield* runEffect(
-      context,
-      "nyc-open-data",
-      tokens,
-      queryNycOpenDataDataset(request).pipe(Effect.provide(context.runtime.soda3Layer))
-    )
-  })
-
-export const handleNycOpenDataExport = (config: {
-  readonly datasetId: string
-  readonly format: Soda3ExportFormat
-  readonly output: string
-  readonly dryRun: boolean
-}) =>
-  Effect.gen(function* () {
-    const context = yield* CliCommandContext
-    const tokens = ["nyc-open-data", "dataset", "export"]
-    const request = {
-      datasetId: config.datasetId,
-      format: config.format
-    }
-
-    if (config.dryRun) {
-      return yield* writeSoda3ExportDryRun({
-        context,
-        apiFamily: "nyc-open-data",
-        tokens,
-        domain: defaultDomain,
-        output: config.output,
-        ...request
-      })
+  },
+  resolveDataset: (datasetId) => ({
+    payload: {
+      datasetId
     }
-
-    return yield* runEffect(
-      context,
-      "nyc-open-data",
-      tokens,
-      Effect.gen(function* () {
-        const response = yield* exportNycOpenDataDataset(request).pipe(
-          Effect.provide(context.runtime.soda3Layer)
-        )
-        return yield* writeResponseToFile(config.output, response)
-      })
-    )
-  })
+  }),
+  query: ({ id, query }) =>
+    queryNycOpenDataDataset({
+      datasetId: id,
+      query
+    }),
+  exportResponse: ({ id, format }) =>
+    exportNycOpenDataDataset({
+      datasetId: id,
+      format
+    })
+})
 
 const nycOpenDataCatalogSearchCommand = Command.make(
   "search",
@@ -165,9 +106,7 @@ const nycOpenDataCatalogSearchCommand = Command.make(
       Flag.withDefault(10),
       Flag.withDescription("Maximum catalog results to request. Defaults to 10.")
     ),
-    dryRun: Flag.boolean("dry-run").pipe(
-      Flag.withDescription("Print the planned request without contacting the provider.")
-    )
+    dryRun: dryRunFlag
   },
   handleNycOpenDataCatalogSearch
 ).pipe(Command.withShortDescription("Search the NYC Open Data catalog."))
@@ -177,64 +116,9 @@ const nycOpenDataCatalogCommand = Command.make("catalog").pipe(
   Command.withSubcommands([nycOpenDataCatalogSearchCommand])
 )
 
-const nycOpenDataDatasetListCommand = Command.make("list", {}, handleNycOpenDataList).pipe(
-  Command.withShortDescription("List curated NYC Open Data descriptors.")
-)
-
-const nycOpenDataDatasetInfoCommand = Command.make(
-  "info",
-  {
-    datasetId: Flag.string("dataset").pipe(
-      Flag.withDescription("NYC Open Data Socrata dataset id.")
-    )
-  },
-  handleNycOpenDataInfo
-).pipe(Command.withShortDescription("Show NYC Open Data dataset metadata."))
-
-const nycOpenDataDatasetQueryCommand = Command.make(
-  "query",
-  {
-    datasetId: Flag.string("dataset").pipe(
-      Flag.withDescription("NYC Open Data Socrata dataset id.")
-    ),
-    select: Flag.string("select").pipe(
-      Flag.withDescription("SoQL select expression or full SELECT query.")
-    ),
-    dryRun: Flag.boolean("dry-run").pipe(
-      Flag.withDescription("Print the planned request without contacting the provider.")
-    )
-  },
-  handleNycOpenDataQuery
-).pipe(Command.withShortDescription("Run a NYC Open Data SODA3 query."))
-
-const nycOpenDataDatasetExportCommand = Command.make(
-  "export",
-  {
-    datasetId: Flag.string("dataset").pipe(
-      Flag.withDescription("NYC Open Data Socrata dataset id.")
-    ),
-    format: Flag.choice("format", ["csv", "json", "geojson"]).pipe(
-      Flag.withDefault("csv"),
-      Flag.withDescription("Export format. Defaults to csv.")
-    ),
-    output: Flag.string("output").pipe(
-      Flag.withDescription("Destination file path for the downloaded response body.")
-    ),
-    dryRun: Flag.boolean("dry-run").pipe(
-      Flag.withDescription("Print the planned request without contacting the provider.")
-    )
-  },
-  handleNycOpenDataExport
-).pipe(Command.withShortDescription("Export a NYC Open Data dataset."))
-
 const nycOpenDataDatasetCommand = Command.make("dataset").pipe(
   Command.withShortDescription("NYC Open Data dataset commands."),
-  Command.withSubcommands([
-    nycOpenDataDatasetListCommand,
-    nycOpenDataDatasetInfoCommand,
-    nycOpenDataDatasetQueryCommand,
-    nycOpenDataDatasetExportCommand
-  ])
+  Command.withSubcommands(nycOpenDataDatasetCommands)
 )
 
 export const nycOpenDataCommand = Command.make("nyc-open-data").pipe(

package/src/commands/root.ts

@@ -2,13 +2,11 @@ import * as Effect from "effect/Effect"
 import * as Command from "effect/unstable/cli/Command"
 import * as Flag from "effect/unstable/cli/Flag"
 import { localBinaryName } from "../index"
-import { catalogCommand } from "./catalog"
 import { mtaCommand } from "./mta"
 import { nycDotCommand } from "./nyc-dot"
 import { nycOpenDataCommand } from "./nyc-open-data"
-import { failCommand } from "./shared"
-import { socrataCommand } from "./socrata"
-import { CliCommandContext } from "./types"
+import { CliCommandContext, failCommand } from "./shared"
+import { catalogCommand, socrataCommand } from "./socrata"
 
 const handleMissingCommand = () =>
   Effect.gen(function* () {