feat: Finalized CLI approach

.changeset/eleven-pillows-eat.md

@@ -0,0 +1,18 @@
+---
+"@dpkit/parquet": minor
+"@dpkit/folder": minor
+"@dpkit/github": minor
+"@dpkit/zenodo": minor
+"@dpkit/arrow": minor
+"dpkit": minor
+"@dpkit/table": minor
+"@dpkit/ckan": minor
+"@dpkit/core": minor
+"@dpkit/file": minor
+"@dpkit/json": minor
+"@dpkit/cli": minor
+"@dpkit/csv": minor
+"@dpkit/zip": minor
+---
+
+Improved CLI implementation

arrow/plugin.ts

@@ -1,5 +1,5 @@
 import type { Resource } from "@dpkit/core"
-import { inferFormat } from "@dpkit/core"
+import { inferResourceFormat } from "@dpkit/core"
 import type { TablePlugin } from "@dpkit/table"
 import type { SaveTableOptions, Table } from "@dpkit/table"
 import { loadArrowTable, saveArrowTable } from "./table/index.ts"
@@ -21,6 +21,6 @@ export class ArrowPlugin implements TablePlugin {
 }
 
 function getIsArrow(resource: Partial<Resource>) {
-  const format = inferFormat(resource)
+  const format = inferResourceFormat(resource)
   return format === "arrow" || format === "feather"
 }

ckan/package/save.ts

@@ -54,20 +54,20 @@ export async function savePackageToCkan(
         basepath,
         withRemote: true,
         withoutFolders: true,
-        saveFile: async props => {
-          const filename = getFilename(props.normalizedPath)
+        saveFile: async options => {
+          const filename = getFilename(options.normalizedPath)
           const ckanResource = denormalizeCkanResource(resource)
 
           const payload = {
             ...ckanResource,
             package_id: datasetName,
-            name: props.denormalizedPath,
+            name: options.denormalizedPath,
             format: getFormat(filename)?.toUpperCase(),
           }
 
           const upload = {
-            name: props.denormalizedPath,
-            data: await blob(await loadFileStream(props.normalizedPath)),
+            name: options.denormalizedPath,
+            data: await blob(await loadFileStream(options.normalizedPath)),
           }
 
           const result = await makeCkanApiRequest<CkanResource>({

cli/commander.d.ts

@@ -0,0 +1,3 @@
+declare module "commander" {
+  export * from "@commander-js/extra-typings"
+}

cli/commands/dialect/errors.tsx

@@ -0,0 +1,62 @@
+import { Command } from "commander"
+import { loadDescriptor, validateDialect } from "dpkit"
+import type { Descriptor } from "dpkit"
+import React from "react"
+import { ReportGrid } from "../../components/ReportGrid.tsx"
+import { helpConfiguration } from "../../helpers/help.ts"
+import { selectResource } from "../../helpers/resource.ts"
+import { Session } from "../../helpers/session.ts"
+import * as params from "../../params/index.ts"
+
+export const errorsDialectCommand = new Command("errors")
+  .configureHelp(helpConfiguration)
+  .description("Show errors for a table dialect from a local or remote path")
+
+  .addArgument(params.positionalTablePath)
+  .addOption(params.fromPackage)
+  .addOption(params.fromResource)
+  .addOption(params.json)
+
+  .action(async (path, options) => {
+    const session = Session.create({
+      title: "Dialect errors",
+      json: options.json,
+    })
+
+    let descriptor: Descriptor | undefined
+
+    if (!path) {
+      const resource = await selectResource(session, options)
+
+      if (!resource.dialect) {
+        Session.terminate("Dialect is not available")
+      }
+
+      if (typeof resource.dialect !== "string") {
+        descriptor = resource.dialect as Descriptor
+      } else {
+        path = resource.dialect
+      }
+    }
+
+    if (!descriptor) {
+      const result = await session.task(
+        "Loading dialect",
+        // @ts-ignore
+        loadDescriptor(path),
+      )
+
+      descriptor = result.descriptor
+    }
+
+    const report = await session.task(
+      "Finding errors",
+      validateDialect(descriptor),
+    )
+
+    if (report.valid) {
+      session.success("Dialect is valid")
+    }
+
+    session.render(report, <ReportGrid report={report} />)
+  })

cli/commands/dialect/index.ts

@@ -0,0 +1,15 @@
+import { Command } from "commander"
+import { helpConfiguration } from "../../helpers/help.ts"
+import { errorsDialectCommand } from "./errors.tsx"
+import { inferDialectCommand } from "./infer.tsx"
+import { showDialectCommand } from "./show.tsx"
+import { validateDialectCommand } from "./validate.tsx"
+
+export const dialectCommand = new Command("dialect")
+  .configureHelp(helpConfiguration)
+  .description("Table Dialect related commands")
+
+  .addCommand(errorsDialectCommand)
+  .addCommand(inferDialectCommand)
+  .addCommand(showDialectCommand)
+  .addCommand(validateDialectCommand)

cli/commands/dialect/infer.tsx

@@ -0,0 +1,34 @@
+import { Command } from "commander"
+import { inferDialect } from "dpkit"
+import React from "react"
+import { DialectGrid } from "../../components/DialectGrid.tsx"
+import { helpConfiguration } from "../../helpers/help.ts"
+import { isEmptyObject } from "../../helpers/object.ts"
+import { selectResource } from "../../helpers/resource.ts"
+import { Session } from "../../helpers/session.ts"
+import * as params from "../../params/index.ts"
+
+export const inferDialectCommand = new Command("infer")
+  .configureHelp(helpConfiguration)
+  .description("Infer a table dialect from a table")
+
+  .addArgument(params.positionalTablePath)
+  .addOption(params.fromPackage)
+  .addOption(params.fromResource)
+  .addOption(params.json)
+
+  .action(async (path, options) => {
+    const session = Session.create({
+      title: "Infer dialect",
+      json: options.json,
+    })
+
+    const resource = path ? { path } : await selectResource(session, options)
+
+    const dialect = await session.task("Loading sample", inferDialect(resource))
+    if (isEmptyObject(dialect)) {
+      Session.terminate("Could not infer dialect")
+    }
+
+    await session.render(dialect, <DialectGrid dialect={dialect} />)
+  })

cli/commands/dialect/show.tsx

@@ -0,0 +1,52 @@
+import { Command } from "commander"
+import { loadDialect } from "dpkit"
+import type { Dialect } from "dpkit"
+import React from "react"
+import { DialectGrid } from "../../components/DialectGrid.tsx"
+import { helpConfiguration } from "../../helpers/help.ts"
+import { isEmptyObject } from "../../helpers/object.ts"
+import { selectResource } from "../../helpers/resource.ts"
+import { Session } from "../../helpers/session.ts"
+import * as params from "../../params/index.ts"
+
+export const showDialectCommand = new Command("show")
+  .configureHelp(helpConfiguration)
+  .description("Show a table dialect from a local or remote path")
+
+  .addArgument(params.positionalTablePath)
+  .addOption(params.fromPackage)
+  .addOption(params.fromResource)
+  .addOption(params.json)
+
+  .action(async (path, options) => {
+    const session = Session.create({
+      title: "Show dialect",
+      json: options.json,
+    })
+
+    let dialect: Dialect | undefined
+
+    if (!path) {
+      const resource = await selectResource(session, options)
+      if (!resource.dialect) {
+        Session.terminate("Dialect is not available")
+      }
+
+      if (typeof resource.dialect !== "string") {
+        dialect = resource.dialect
+      } else {
+        path = resource.dialect
+      }
+    }
+
+    if (!dialect) {
+      // @ts-ignore
+      dialect = await session.task("Loading dialect", loadDialect(path))
+    }
+
+    if (isEmptyObject(dialect)) {
+      Session.terminate("Dialect is not available")
+    }
+
+    await session.render(dialect, <DialectGrid dialect={dialect} />)
+  })

cli/commands/dialect/validate.tsx

@@ -0,0 +1,63 @@
+import { Command } from "commander"
+import { loadDescriptor, validateDialect } from "dpkit"
+import type { Descriptor } from "dpkit"
+import React from "react"
+import { ReportGrid } from "../../components/ReportGrid.tsx"
+import { helpConfiguration } from "../../helpers/help.ts"
+import { selectResource } from "../../helpers/resource.ts"
+import { Session } from "../../helpers/session.ts"
+import * as params from "../../params/index.ts"
+
+export const validateDialectCommand = new Command("validate")
+  .configureHelp(helpConfiguration)
+  .description("Validate a table dialect from a local or remote path")
+
+  .addArgument(params.positionalTablePath)
+  .addOption(params.fromPackage)
+  .addOption(params.fromResource)
+  .addOption(params.json)
+
+  .action(async (path, options) => {
+    const session = Session.create({
+      title: "Validate dialect",
+      json: options.json,
+    })
+
+    let descriptor: Descriptor | undefined
+
+    if (!path) {
+      const resource = await selectResource(session, options)
+
+      if (!resource.dialect) {
+        Session.terminate("Dialect is not available")
+      }
+
+      if (typeof resource.dialect !== "string") {
+        descriptor = resource.dialect as Descriptor
+      } else {
+        path = resource.dialect
+      }
+    }
+
+    if (!descriptor) {
+      const result = await session.task(
+        "Loading dialect",
+        // @ts-ignore
+        loadDescriptor(path),
+      )
+
+      descriptor = result.descriptor
+    }
+
+    const report = await session.task(
+      "Validating dialect",
+      // @ts-ignore
+      validateDialect(descriptor),
+    )
+
+    if (report.valid) {
+      session.success("Dialect is valid")
+    }
+
+    session.render(report, <ReportGrid report={report} groupBy="type" />)
+  })

cli/commands/file/copy.ts

@@ -0,0 +1,41 @@
+import { Command } from "commander"
+import { copyFile } from "dpkit"
+import { helpConfiguration } from "../../helpers/help.ts"
+import { selectResource } from "../../helpers/resource.ts"
+import { Session } from "../../helpers/session.ts"
+import * as params from "../../params/index.ts"
+
+export const copyFileCommand = new Command("copy")
+  .configureHelp(helpConfiguration)
+  .description("Copy a local or remote file to a local path")
+
+  .addArgument(params.positionalFilePath)
+  .addOption(params.toPath.makeOptionMandatory())
+  .addOption(params.fromPackage)
+  .addOption(params.fromResource)
+
+  .action(async (path, options) => {
+    const session = Session.create({
+      title: "Copy file",
+    })
+
+    if (!path) {
+      const resource = await selectResource(session, options)
+
+      if (typeof resource.path !== "string") {
+        Session.terminate("Only single file resources are supported")
+      }
+
+      path = resource.path
+    }
+
+    await session.task(
+      "Copying file",
+      copyFile({
+        sourcePath: path,
+        targetPath: options.toPath,
+      }),
+    )
+
+    session.success(`File from "${path}" copied to "${options.toPath}"`)
+  })