dbcat 0.0.11 → 0.0.13

package/README.md

@@ -33,11 +33,11 @@ echo "SELECT * FROM users" | bunx dbcat ./data.db
 
 ### Options
 
-| Flag           | Description                                       |
-|----------------|---------------------------------------------------|
-| `--full`, `-f` | Show all rows when browsing tables (default: 100) |
-| `--json`       | Output as JSON (indented if TTY)                  |
-| `--json=color` | Output as normal object console.log               |
+| Flag           | Description                                                   |
+|----------------|---------------------------------------------------------------|
+| `--full`, `-f` | Show all rows & data when browsing tables (default: 100 rows) |
+| `--json`       | Output as JSON (indented if TTY)                              |
+| `--json=color` | Output as normal object console.log                           |
 
 Piped queries always return all rows.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dbcat",
-  "version": "0.0.11",
+  "version": "0.0.13",
   "description": "A simple CLI to view database tables. Supports PostgreSQL, MySQL, and SQLite.",
   "author": "RiskyMH",
   "license": "MIT",

package/src/index.ts

@@ -121,7 +121,7 @@ export function getTableData(
   tableName: string,
   limit?: number
 ): Promise<Record<string, unknown>[]> {
-  if (limit === undefined) {
+  if (limit === undefined || limit === Infinity) {
     return sql`SELECT * FROM ${sql(tableName)}`;
   }
   return sql`SELECT * FROM ${sql(tableName)} LIMIT ${limit}`;
@@ -135,14 +135,15 @@ function displayTable(
   tableName: string,
   rows: Record<string, unknown>[],
   totalRows?: number,
-  maxRows?: number
+  maxRows?: number,
+  fullContent?: boolean
 ) {
-  console.log();
-  printTable(rows, { title: tableName, totalRows, maxRows });
+  console.log("");
+  printTable(rows, { title: tableName, totalRows, maxRows, fullContent });
 }
 
 function displayQueryResult(rows: Record<string, unknown>[]) {
-  printTable(rows, { title: "Result", maxRows: Infinity });
+  printTable(rows, { title: "Result", maxRows: Infinity, fullContent: true });
 }
 
 async function readStdin(): Promise<string | null> {
@@ -162,12 +163,18 @@ function parseArgs() {
   const args = process.argv.slice(2);
   let input: string | undefined;
   let full = false;
-  let help = false
+  let help = false;
   let json: false | "plain" | "color" = false;
+  let fullRows = false;
+  let fullContent = false;
 
   for (const arg of args) {
     if (arg === "--full" || arg === "-f") {
       full = true;
+    } else if (arg === "--full-rows") {
+      fullRows = true;
+    } else if (arg === "--full-content") {
+      fullContent = true;
     } else if (arg === "--help" || arg === "-h") {
       help = true;
     } else if (arg === "--json") {
@@ -179,7 +186,7 @@ function parseArgs() {
     }
   }
 
-  return { input, full, json, help };
+  return { input, full, json, help, fullRows, fullContent };
 }
 
 const DEFAULT_LIMIT = 100;
@@ -194,6 +201,11 @@ function showUsageAndExit(): never {
   console.error("  dbcat https://example.com/data.db");
   console.error("");
   console.error("Or set DATABASE_URL environment variable.");
+  console.error("");
+  console.error("Flags:");
+  console.error("  --full  : Show the entire table and wrap cell values to fit column widths");
+  console.error("  --json  : Output as JSON instead of a visual table");
+  console.error("  --help  : Show this help message");
   process.exit(1);
 }
 
@@ -207,7 +219,7 @@ function outputJson(data: unknown, color: boolean) {
 }
 
 async function main() {
-  const { input, full, json, help } = parseArgs();
+  const { input, full, json, help, fullRows, fullContent } = parseArgs();
 
   if ((!input && !process.env.DATABASE_URL) || help) {
     showUsageAndExit();
@@ -295,15 +307,18 @@ async function main() {
           console.log(`${dim}No tables found.${reset}`);
         } else {
           for (const table of tables) {
-            if (full) {
+            const maxRows = (full || fullRows) ? Infinity : DEFAULT_LIMIT;
+            const fullContentFlag = full || fullContent;
+
+            if (maxRows === Infinity) {
               const data = await getTableData(sql, table.name);
-              displayTable(table.name, data, undefined, Infinity);
+              displayTable(table.name, data, undefined, Infinity, fullContentFlag);
             } else {
               const [count, data] = await Promise.all([
                 getTableCount(sql, table.name),
-                getTableData(sql, table.name, DEFAULT_LIMIT),
+                getTableData(sql, table.name, maxRows),
               ]);
-              displayTable(table.name, data, count, DEFAULT_LIMIT);
+              displayTable(table.name, data, count, maxRows, fullContentFlag);
             }
           }
         }

package/src/table.ts

@@ -74,6 +74,49 @@ export interface TableOptions {
   maxRows?: number;
   title?: string;
   totalRows?: number;
+  fullContent?: boolean;
+}
+
+function wrapLines(str: string, maxWidth: number): string[] {
+  // Split input into logical words, wrap to fit maxWidth
+  const raw = str.split(/\n/g).join(" ");
+  if (raw === "") return [""];
+
+  let lines: string[] = [];
+  let current = "";
+
+  const tokens = raw.split(/([ ]+)/);
+  for (const token of tokens) {
+    let fragment = token;
+    while (fragment.length > 0) {
+      const width = Bun.stringWidth(current + fragment);
+      if (width > maxWidth) {
+        if (current.length > 0) {
+          lines.push(current);
+          current = "";
+        } else {
+          let cutPoint = 1;
+          while (cutPoint < fragment.length && Bun.stringWidth(fragment.slice(0, cutPoint)) < maxWidth) {
+            cutPoint++;
+          }
+          lines.push(fragment.slice(0, cutPoint));
+          fragment = fragment.slice(cutPoint);
+        }
+      } else {
+        current += fragment;
+        fragment = "";
+      }
+    }
+    if (Bun.stringWidth(current) >= maxWidth) {
+      lines.push(current);
+      current = "";
+    }
+  }
+  if (current.length > 0) {
+    lines.push(current);
+  }
+
+  return lines;
 }
 
 export function printTable(
@@ -138,7 +181,7 @@ export function printTable(
   const colWidths: number[] = allColumns.map((col) => Bun.stringWidth(col));
   const formattedRows: string[][] = displayRows.map((row) =>
     allColumns.map((col, i) => {
-      const formatted = formatValue(row[col]).replace(/\n/g, " ");
+      const formatted = formatValue(row[col]).replace(/\n/g, "\\n");
       colWidths[i] = Math.max(colWidths[i]!, Bun.stringWidth(formatted));
       return formatted;
     }),
@@ -261,18 +304,42 @@ export function printTable(
     `${dim}${BOX.headerLeft}${BOX.horizontal}${headerSep}${BOX.horizontal}${BOX.headerRight}${reset}`,
   );
 
-  for (const row of visibleFormattedRows) {
-    const line = row
-      .map((val, i) => {
-        const truncated = truncate(val, visibleColWidths[i]!);
-        return visibleIsNumeric[i]
-          ? padLeft(truncated, visibleColWidths[i]!)
-          : padRight(truncated, visibleColWidths[i]!);
-      })
-      .join(` ${dim}${BOX.vertical}${reset} `);
-    console.log(
-      `${dim}${BOX.vertical}${reset} ${line} ${dim}${BOX.vertical}${reset}`,
-    );
+  if (options.fullContent) {
+    for (let rowIdx = 0; rowIdx < visibleFormattedRows.length; rowIdx++) {
+      const row = visibleFormattedRows[rowIdx] ?? [];
+      const wrapped = row.map((val, i) => wrapLines(val, visibleColWidths[i]!));
+      const rowHeight = Math.max(...wrapped.map(x => x.length));
+      for (let lineIdx = 0; lineIdx < rowHeight; lineIdx++) {
+        const pieces = wrapped.map((cellLines, i) => {
+          const part: string = typeof cellLines[lineIdx] === "string" ? cellLines[lineIdx]! : "";
+          return visibleIsNumeric[i]
+            ? padLeft(truncate(part, visibleColWidths[i]!), visibleColWidths[i]!)
+            : padRight(truncate(part, visibleColWidths[i]!), visibleColWidths[i]!);
+        });
+        const line = pieces.join(` ${dim}${BOX.vertical}${reset} `);
+        console.log(`${dim}${BOX.vertical}${reset} ${line} ${dim}${BOX.vertical}${reset}`);
+      }
+      if (rowIdx < visibleFormattedRows.length - 1) {
+        const rowSep = visibleColWidths
+          .map((w) => BOX.horizontal.repeat(w))
+          .join(`${BOX.horizontal}${BOX.headerCross}${BOX.horizontal}`);
+        console.log(`${dim}${BOX.headerLeft}${BOX.horizontal}${rowSep}${BOX.horizontal}${BOX.headerRight}${reset}`);
+      }
+    }
+  } else {
+    for (const row of visibleFormattedRows) {
+      const line = row
+        .map((val, i) => {
+          const truncated = truncate(val, visibleColWidths[i]!);
+          return visibleIsNumeric[i]
+            ? padLeft(truncated, visibleColWidths[i]!)
+            : padRight(truncated, visibleColWidths[i]!);
+        })
+        .join(` ${dim}${BOX.vertical}${reset} `);
+      console.log(
+        `${dim}${BOX.vertical}${reset} ${line} ${dim}${BOX.vertical}${reset}`,
+      );
+    }
   }
 
   if (infoText) {