@dboio/cli 0.4.1

package/src/lib/formatter.js

@@ -0,0 +1,310 @@
+import chalk from 'chalk';
+import { log } from './logger.js';
+
+export function formatResponse(result, options = {}) {
+  // --jq mode: filter then print
+  if (options.jq) {
+    const filtered = jqFilter(result.data, options.jq);
+    printJson(filtered);
+    return;
+  }
+
+  // --json mode: colorized full JSON
+  if (options.json) {
+    printJson(result.data);
+    return;
+  }
+
+  if (result.successful) {
+    log.success(`Request successful ${chalk.dim(result.url || '')}`);
+  } else {
+    log.error(`Request failed ${chalk.dim(result.url || '')}`);
+  }
+
+  if (result.messages && result.messages.length > 0) {
+    for (const msg of result.messages) {
+      log.label('Message', msg);
+    }
+  }
+
+  if (result.payload) {
+    formatPayload(result.payload, options);
+  }
+}
+
+function formatPayload(payload, options = {}) {
+  if (!payload) return;
+
+  // Input API results
+  if (payload.Results) {
+    const r = payload.Results;
+    if (r.Add && r.Add.length > 0) {
+      log.info(`Added ${r.Add.length} record(s)`);
+      for (const rec of r.Add) {
+        const uid = rec.UID || rec.uid || '';
+        const id = rec.RowID || rec.rowid || rec.ID || '';
+        log.label('    UID', uid);
+        if (id) log.label('    RowID', id.toString());
+      }
+    }
+    if (r.Edit && r.Edit.length > 0) {
+      log.info(`Edited ${r.Edit.length} record(s)`);
+    }
+    if (r.Delete && r.Delete.length > 0) {
+      log.info(`Deleted ${r.Delete.length} record(s)`);
+    }
+    return;
+  }
+
+  // Output/query results — show row count or raw data
+  if (Array.isArray(payload)) {
+    log.info(`${payload.length} row(s) returned`);
+    if (payload.length > 0) {
+      formatTable(payload, options);
+    }
+    return;
+  }
+
+  // Generic object payload
+  if (typeof payload === 'object') {
+    printJson(payload);
+  } else {
+    log.plain(String(payload));
+  }
+}
+
+// Sensitive column names — values get masked
+const SENSITIVE_COLUMNS = new Set([
+  'password', 'passkey', 'secret', 'token', 'apikey', 'api_key',
+  'secureconnectionstring', 'connectionstring', 'customencryption',
+]);
+
+function formatTable(rows, options = {}) {
+  if (rows.length === 0) return;
+
+  const termWidth = process.stdout.columns || 120;
+  let allColumns = Object.keys(rows[0]);
+
+  // --columns filter: only show specified columns
+  if (options.columns) {
+    const picked = options.columns.split(',').map(c => c.trim());
+    allColumns = allColumns.filter(c => picked.some(p =>
+      c.toLowerCase() === p.toLowerCase()
+    ));
+  }
+
+  // Hide columns where ALL values are null/empty (unless explicitly requested)
+  if (!options.columns) {
+    allColumns = allColumns.filter(col => {
+      return rows.some(r => r[col] !== null && r[col] !== undefined && r[col] !== '');
+    });
+  }
+
+  if (allColumns.length === 0) return;
+
+  // Calculate column widths
+  const widths = {};
+  for (const col of allColumns) {
+    const maxData = Math.max(...rows.map(r => displayValue(r[col], col).length));
+    widths[col] = Math.max(col.length, Math.min(maxData, 30));
+  }
+
+  // Shrink columns to fit terminal width
+  const gap = 2;
+  let totalWidth = allColumns.reduce((sum, c) => sum + widths[c], 0) + (allColumns.length - 1) * gap;
+
+  if (totalWidth > termWidth && allColumns.length > 1) {
+    // First pass: shrink any column wider than 20 chars
+    while (totalWidth > termWidth) {
+      const widest = allColumns.reduce((a, b) => widths[a] > widths[b] ? a : b);
+      if (widths[widest] <= 6) break; // can't shrink further
+      widths[widest] = Math.max(6, widths[widest] - 1);
+      totalWidth = allColumns.reduce((sum, c) => sum + widths[c], 0) + (allColumns.length - 1) * gap;
+    }
+  }
+
+  // Header
+  const header = allColumns.map(c => c.substring(0, widths[c]).padEnd(widths[c])).join('  ');
+  log.plain(chalk.cyan(header));
+  log.plain(chalk.dim('─'.repeat(Math.min(header.length, termWidth))));
+
+  // Rows
+  for (const row of rows) {
+    const line = allColumns.map(c => {
+      const val = displayValue(row[c], c);
+      return val.substring(0, widths[c]).padEnd(widths[c]);
+    }).join('  ');
+    log.plain(line);
+  }
+}
+
+function displayValue(value, columnName) {
+  if (value === null || value === undefined) return '';
+
+  // Mask sensitive columns
+  if (SENSITIVE_COLUMNS.has(columnName.toLowerCase())) {
+    const str = String(value);
+    if (str.length === 0) return '';
+    return str.substring(0, 3) + '***';
+  }
+
+  const str = String(value);
+
+  // Truncate very long values (base64, blobs, etc.)
+  if (str.length > 60) {
+    return str.substring(0, 57) + '...';
+  }
+
+  return str;
+}
+
+/**
+ * Lightweight jq-style JSON filter.
+ *
+ * Supported expressions:
+ *   .                          identity
+ *   .key                       access key
+ *   .key.nested                nested access
+ *   .key[].field               iterate array, pluck field
+ *   .[0]                       array index
+ *   .[]                        iterate array
+ *   .[] | .field               pipe: iterate then access
+ *   .["key.with.dots"]         bracket notation
+ */
+export function jqFilter(data, expr) {
+  if (!expr || expr.trim() === '.') return data;
+
+  // Handle pipe: .[] | .field
+  if (expr.includes(' | ')) {
+    const [left, right] = expr.split(' | ', 2);
+    const intermediate = jqFilter(data, left.trim());
+    if (Array.isArray(intermediate)) {
+      return intermediate.map(item => jqFilter(item, right.trim()));
+    }
+    return jqFilter(intermediate, right.trim());
+  }
+
+  let current = data;
+  // Tokenize the expression: split by . but respect brackets
+  const tokens = tokenize(expr);
+
+  for (const token of tokens) {
+    if (current === undefined || current === null) return null;
+
+    // Array iteration: []
+    if (token === '[]') {
+      if (!Array.isArray(current)) return null;
+      // If there are more tokens after [], we need to map
+      continue;
+    }
+
+    // Array iteration with remaining path: [].field
+    if (token.startsWith('[]')) {
+      if (!Array.isArray(current)) return null;
+      const remaining = token.substring(2);
+      current = current.map(item => jqFilter(item, '.' + remaining));
+      continue;
+    }
+
+    // Array index: [0], [1], etc.
+    const indexMatch = token.match(/^\[(\d+)]$/);
+    if (indexMatch) {
+      const idx = parseInt(indexMatch[1], 10);
+      current = Array.isArray(current) ? current[idx] : null;
+      continue;
+    }
+
+    // Bracket notation: ["key.name"]
+    const bracketMatch = token.match(/^\["(.+)"]$/);
+    if (bracketMatch) {
+      current = current[bracketMatch[1]];
+      continue;
+    }
+
+    // Plain key access
+    if (typeof current === 'object' && current !== null) {
+      current = current[token];
+    } else {
+      return null;
+    }
+  }
+
+  // If current is still an array and we had [], flatten single-field plucks
+  return current;
+}
+
+function tokenize(expr) {
+  const tokens = [];
+  let i = expr.startsWith('.') ? 1 : 0; // skip leading dot
+
+  while (i < expr.length) {
+    if (expr[i] === '.') {
+      i++;
+      continue;
+    }
+
+    if (expr[i] === '[') {
+      // Find matching ]
+      const end = expr.indexOf(']', i);
+      if (end === -1) break;
+      let token = expr.substring(i, end + 1);
+      // Check if there's more after ] (like [].field)
+      if (end + 1 < expr.length && expr[end + 1] === '.') {
+        // Collect remaining path segment for array iteration
+        const nextDot = expr.indexOf('.', end + 2);
+        const nextBracket = expr.indexOf('[', end + 2);
+        let segEnd;
+        if (nextDot === -1 && nextBracket === -1) segEnd = expr.length;
+        else if (nextDot === -1) segEnd = nextBracket;
+        else if (nextBracket === -1) segEnd = nextDot;
+        else segEnd = Math.min(nextDot, nextBracket);
+        token += expr.substring(end + 1, segEnd);
+        i = segEnd;
+      } else {
+        i = end + 1;
+      }
+      tokens.push(token);
+      continue;
+    }
+
+    // Regular key: read until next . or [
+    let end = i;
+    while (end < expr.length && expr[end] !== '.' && expr[end] !== '[') end++;
+    tokens.push(expr.substring(i, end));
+    i = end;
+  }
+
+  return tokens;
+}
+
+/**
+ * Print JSON with syntax highlighting.
+ */
+function printJson(data) {
+  const json = JSON.stringify(data, null, 2);
+  if (!json) { log.plain('null'); return; }
+
+  const colored = json.replace(
+    /("(?:[^"\\]|\\.)*")\s*:/g,  // keys
+    (match, key) => chalk.cyan(key) + ':'
+  ).replace(
+    /:\s*("(?:[^"\\]|\\.)*")/g,  // string values
+    (match, val) => ': ' + chalk.green(val)
+  ).replace(
+    /:\s*(\d+\.?\d*)/g,          // numbers
+    (match, num) => ': ' + chalk.yellow(num)
+  ).replace(
+    /:\s*(true|false|null)/g,    // booleans/null
+    (match, val) => ': ' + chalk.magenta(val)
+  );
+
+  log.plain(colored);
+}
+
+export function formatError(err) {
+  if (err.message) {
+    log.error(err.message);
+  } else {
+    log.error(String(err));
+  }
+}

package/src/lib/input-parser.js

@@ -0,0 +1,212 @@
+import { readFile } from 'fs/promises';
+import { log } from './logger.js';
+import { loadUserInfo } from './config.js';
+
+/**
+ * Parse DBO input syntax and build form data.
+ *
+ * Syntax: RowID:add1;column:entity.Column=value
+ *         RowUID:abc123;column:content.Content@filepath
+ *         RowID:del123;entity:user=true
+ *
+ * The @filepath syntax means "read file contents and use as value" (URL-encoded, not multipart).
+ */
+
+export async function buildInputBody(dataExpressions, extraParams = {}) {
+  const parts = [];
+
+  // Add extra params first (_confirm, _OverrideTicketID, etc.)
+  for (const [key, value] of Object.entries(extraParams)) {
+    parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(value)}`);
+  }
+
+  for (const expr of dataExpressions) {
+    // Split by & to handle multiple ops in one -d string
+    const ops = expr.split('&');
+    for (const op of ops) {
+      const encoded = await encodeInputExpression(op.trim());
+      parts.push(encoded);
+    }
+  }
+
+  return parts.join('&');
+}
+
+async function encodeInputExpression(expr) {
+  // Check if value part contains @filepath
+  // Format: key=value or key@filepath
+  // The key is everything before the first = or @ that acts as value separator
+  // DBO syntax: RowID:add1;column:content.Content@path/to/file.css
+  //             RowID:add1;column:user.Name=John
+
+  // Find the value separator: last @ or = in the expression
+  // But we need to be careful: the @ in column:entity.Column@file is the value separator,
+  // while : and ; are part of the DBO key syntax
+
+  // Strategy: find the position of the first = or the last @ that comes after a column reference
+  const eqIdx = expr.indexOf('=');
+  const atIdx = findValueAtSign(expr);
+
+  if (atIdx !== -1 && (eqIdx === -1 || atIdx < eqIdx)) {
+    // @filepath syntax: read file and URL-encode
+    const key = expr.substring(0, atIdx);
+    const filePath = expr.substring(atIdx + 1);
+    const content = await readFile(filePath, 'utf8');
+    return `${encodeURIComponent(key)}=${encodeURIComponent(content)}`;
+  } else if (eqIdx !== -1) {
+    // =value syntax: direct value
+    const key = expr.substring(0, eqIdx);
+    const value = expr.substring(eqIdx + 1);
+    return `${encodeURIComponent(key)}=${encodeURIComponent(value)}`;
+  } else {
+    // No value separator, encode the whole thing
+    return encodeURIComponent(expr);
+  }
+}
+
+/**
+ * Find the @ sign that acts as a value separator (file reference),
+ * not the @ in email addresses or other contexts.
+ *
+ * In DBO syntax, the @ follows the pattern:
+ *   column:entity.ColumnName@filepath
+ * So it comes after a dot-separated entity.column reference.
+ */
+function findValueAtSign(expr) {
+  // Look for @ that appears after column:entity.Column pattern
+  // The pattern is: ...column:word.Word@...
+  const match = expr.match(/;column:[a-zA-Z_]+\.[a-zA-Z_]+@/);
+  if (match) {
+    return expr.indexOf('@', match.index);
+  }
+  return -1;
+}
+
+// Patterns that indicate a missing user identity in the server response
+const USER_ID_PATTERNS = [
+  'LoggedInUser_UID',
+  'LoggedInUserID',
+  'CurrentUserID',
+  'CurrentUser_UID',
+  'UserID',
+];
+
+/**
+ * Check if a submission result contains recoverable errors that can be
+ * resolved by prompting the user for missing parameters.
+ *
+ * Detects:
+ * - ticket_lookup_required_error → prompts for Ticket ID
+ * - LoggedInUser_UID, LoggedInUserID, CurrentUserID, UserID not found
+ *   → prompts for User ID or UID (session not authenticated)
+ *
+ * Returns an object of extra params to add on retry, or null if no
+ * recoverable errors were found.
+ */
+export async function checkSubmitErrors(result) {
+  const messages = result.messages || result.data?.Messages || [];
+  const allText = messages.filter(m => typeof m === 'string').join(' ');
+
+  const needsTicket = allText.includes('ticket_lookup_required_error');
+
+  // Detect which user identity variant is needed
+  const matchedUserPattern = USER_ID_PATTERNS.find(p => allText.includes(p));
+  const needsUser = !!matchedUserPattern;
+  const needsUserUid = matchedUserPattern && matchedUserPattern.includes('UID');
+  const needsUserId = matchedUserPattern && !needsUserUid;
+
+  if (!needsTicket && !needsUser) return null;
+
+  const prompts = [];
+  const retryParams = {};
+
+  if (needsUser) {
+    const idType = needsUserUid ? 'UID' : 'ID';
+    log.warn(`This operation requires an authenticated user (${matchedUserPattern}).`);
+    log.dim('  Your session may have expired, or you may not be logged in.');
+    log.dim('  You can log in with "dbo login" to avoid this prompt in the future.');
+
+    // Check for stored user info from a previous login
+    const stored = await loadUserInfo();
+    const storedValue = needsUserUid ? stored.userUid : (stored.userId || stored.userUid);
+    const storedLabel = needsUserUid
+      ? (stored.userUid ? `UID: ${stored.userUid}` : null)
+      : (stored.userId ? `ID: ${stored.userId}` : (stored.userUid ? `UID: ${stored.userUid}` : null));
+
+    if (storedValue) {
+      log.dim(`  Stored session user ${storedLabel}`);
+      prompts.push({
+        type: 'list',
+        name: 'userChoice',
+        message: `User ${idType} Required:`,
+        choices: [
+          { name: `Use session user (${storedLabel})`, value: storedValue },
+          { name: `Enter a different User ${idType}`, value: '_custom' },
+        ],
+      });
+      prompts.push({
+        type: 'input',
+        name: 'customUserValue',
+        message: `Custom User ${idType}:`,
+        when: (answers) => answers.userChoice === '_custom',
+        validate: v => v.trim() ? true : `User ${idType} is required`,
+      });
+    } else {
+      prompts.push({
+        type: 'input',
+        name: 'userValue',
+        message: `User ${idType} Required:`,
+        validate: v => v.trim() ? true : `User ${idType} is required`,
+      });
+    }
+  }
+
+  if (needsTicket) {
+    log.warn('This operation requires a Ticket ID.');
+    prompts.push({
+      type: 'input',
+      name: 'ticketId',
+      message: 'Ticket ID Required:',
+      validate: v => v.trim() ? true : 'Ticket ID is required',
+    });
+  }
+
+  const inquirer = (await import('inquirer')).default;
+  const answers = await inquirer.prompt(prompts);
+
+  if (answers.ticketId) retryParams['_OverrideTicketID'] = answers.ticketId.trim();
+
+  // Resolve user identity from choice or direct input
+  const userValue = answers.userValue
+    || (answers.userChoice === '_custom' ? answers.customUserValue : answers.userChoice);
+  if (userValue) {
+    // Use the appropriate override param based on what the server asked for
+    if (needsUserUid) {
+      retryParams['_OverrideUserUID'] = userValue.trim();
+    } else {
+      retryParams['_OverrideUserID'] = userValue.trim();
+    }
+  }
+
+  return retryParams;
+}
+
+/**
+ * Parse file arguments in the format: field=@path or just @path
+ * Returns objects suitable for multipart upload.
+ */
+export function parseFileArg(arg) {
+  if (arg.includes('=@')) {
+    const [field, path] = arg.split('=@', 2);
+    const fileName = path.split('/').pop();
+    return { fieldName: field, filePath: path, fileName };
+  }
+  if (arg.startsWith('@')) {
+    const path = arg.substring(1);
+    const fileName = path.split('/').pop();
+    return { fieldName: 'file', filePath: path, fileName };
+  }
+  // Treat as: file=@path
+  const fileName = arg.split('/').pop();
+  return { fieldName: 'file', filePath: arg, fileName };
+}

package/src/lib/logger.js

@@ -0,0 +1,12 @@
+import chalk from 'chalk';
+
+export const log = {
+  info(msg) { console.log(chalk.blue('ℹ'), msg); },
+  success(msg) { console.log(chalk.green('✓'), msg); },
+  warn(msg) { console.log(chalk.yellow('⚠'), msg); },
+  error(msg) { console.error(chalk.red('✗'), msg); },
+  dim(msg) { console.log(chalk.dim(msg)); },
+  plain(msg) { console.log(msg); },
+  verbose(msg) { console.log(chalk.dim('  →'), chalk.dim(msg)); },
+  label(label, value) { console.log(chalk.dim(`  ${label}:`), value); },
+};