Migrated to TypeScript.

src/cli/utils.ts

@@ -0,0 +1,205 @@
+// SPDX-License-Identifier: MIT
+
+import jmespath from "jmespath";
+
+import { toMarkdownTable } from "../markdown.ts";
+
+type HeaderSpec =
+  | { mode: "auto" }
+  | { mode: "original" }
+  | { mode: "list"; labels: string[] }
+  | { mode: "map"; map: Record<string, string> };
+
+type OutputFormat = "json" | "table" | "alignedtable" | "prettytable" | "tsv";
+
+type Scalar = string | number | boolean | null | undefined;
+type ScalarRow = Record<string, Scalar>;
+
+export function outputFiltered(object: unknown, query?: string): unknown {
+  return query
+    ? jmespath.search(object, query)
+    : object;
+}
+
+export function parseHeaderSpec(headerValue?: string): HeaderSpec {
+  if (!headerValue) {
+    return { mode: "auto" };
+  }
+
+  const raw = headerValue.trim();
+  if (raw === "" || raw.toLowerCase() === "auto" || raw.toLowerCase() === "a") {
+    return { mode: "auto" };
+  }
+  if (raw.toLowerCase() === "original" || raw.toLowerCase() === "o") {
+    return { mode: "original" };
+  }
+
+  const parts = raw.split(",").map((p) => p.trim()).filter(Boolean);
+  const isMap = parts.some((p) => p.includes(":"));
+
+  if (!isMap) {
+    return { mode: "list", labels: parts };
+  }
+
+  const map: Record<string, string> = {};
+  for (const part of parts) {
+    const idx = part.indexOf(":");
+    if (idx < 0) {
+      throw new Error(`Invalid --header mapping segment: '${part}'`);
+    }
+    const key = part.slice(0, idx).trim();
+    const label = part.slice(idx + 1).trim();
+    if (!key || !label) {
+      throw new Error(`Invalid --header mapping segment: '${part}'`);
+    }
+    map[key] = label;
+  }
+
+  return { mode: "map", map };
+}
+
+export function normalizeOutputFormat(outputValue?: string): OutputFormat {
+  if (outputValue == null) {
+    return "json";
+  }
+
+  const raw = outputValue.toLowerCase();
+  if (raw === "json") {
+    throw new Error("JSON is the default output. Omit --output to use it.");
+  }
+  if (raw === "j") {
+    throw new Error("JSON is the default output. Omit --output to use it.");
+  }
+  if (raw === "table" || raw === "t") return "table";
+  if (raw === "alignedtable" || raw === "at") return "alignedtable";
+  if (raw === "prettytable" || raw === "pt") return "prettytable";
+  if (raw === "tsv") return "tsv";
+  throw new Error("--output must be one of: table|t, alignedtable|at, prettytable|pt, tsv");
+}
+
+function isScalar(value: unknown): value is Scalar {
+  return value == null || typeof value !== "object";
+}
+
+function getScalarRowsAndHeaders(value: unknown): { headers: string[]; rows: ScalarRow[] } {
+  let rows: Array<Record<string, unknown>>;
+  if (Array.isArray(value)) {
+    rows = value.map((item) =>
+      item && typeof item === "object" && !Array.isArray(item)
+        ? item as Record<string, unknown>
+        : { value: item },
+    );
+  } else if (value && typeof value === "object") {
+    rows = [value as Record<string, unknown>];
+  } else {
+    rows = [{ value }];
+  }
+
+  if (rows.length === 0) {
+    return {
+      headers: ["result"],
+      rows: [{ result: "" }],
+    };
+  }
+
+  const headers = [...new Set(rows.flatMap((row) => Object.keys(row)))]
+    .filter((key) =>
+      rows.every((row) => isScalar(row[key])),
+    );
+
+  if (headers.length === 0) {
+    return {
+      headers: ["result"],
+      rows: [{ result: "" }],
+    };
+  }
+
+  const scalarRows: ScalarRow[] = rows.map((row) => {
+    const result: ScalarRow = {};
+    for (const [key, rowValue] of Object.entries(row)) {
+      if (isScalar(rowValue)) {
+        result[key] = rowValue;
+      }
+    }
+    return result;
+  });
+
+  return { headers, rows: scalarRows };
+}
+
+function toTsv(value: unknown): string {
+  const { headers, rows } = getScalarRowsAndHeaders(value);
+  const lines = rows.map((row) =>
+    headers
+      .map((header) => (row[header] == null ? "" : String(row[header]).replaceAll("\t", " ").replaceAll("\n", " ")))
+      .join("\t"),
+  );
+  return lines.join("\n");
+}
+
+export function omitPermissionGuidColumns(value: unknown): unknown {
+  if (Array.isArray(value)) {
+    return value.map((item) => omitPermissionGuidColumns(item));
+  }
+  if (!value || typeof value !== "object") {
+    return value;
+  }
+  const { resourceAppId, permissionId, ...rest } = value as Record<string, unknown>;
+  void resourceAppId;
+  void permissionId;
+  return rest;
+}
+
+export async function readJsonFromStdin(): Promise<unknown> {
+  const input = await new Promise<string>((resolve, reject) => {
+    let data = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk: string) => {
+      data += chunk;
+    });
+    process.stdin.on("end", () => {
+      resolve(data);
+    });
+    process.stdin.on("error", (err) => {
+      reject(err);
+    });
+  });
+  if (!input.trim()) {
+    throw new Error("No JSON input provided on stdin");
+  }
+
+  try {
+    return JSON.parse(input) as unknown;
+  } catch (err) {
+    throw new Error(`Invalid JSON input on stdin: ${(err as Error).message}`);
+  }
+}
+
+export function renderOutput(
+  command: string,
+  output: unknown,
+  outputFormat: OutputFormat,
+  headerSpec: HeaderSpec,
+): void {
+  if (outputFormat === "tsv") {
+    console.log(toTsv(output));
+    return;
+  }
+
+  if (command === "table") {
+    console.log(toMarkdownTable(
+      output,
+      outputFormat === "alignedtable" || outputFormat === "prettytable",
+      outputFormat === "prettytable",
+      headerSpec,
+    ));
+  } else if (outputFormat === "alignedtable") {
+    console.log(toMarkdownTable(output, true, false, headerSpec));
+  } else if (outputFormat === "prettytable") {
+    console.log(toMarkdownTable(output, true, true, headerSpec));
+  } else if (outputFormat === "table") {
+    console.log(toMarkdownTable(output, false, false, headerSpec));
+  } else {
+    console.log(JSON.stringify(output, null, 2));
+  }
+}