trello-cli-unofficial 0.7.6 → 0.8.0

package/src/shared/ErrorHandler.ts

@@ -0,0 +1,233 @@
+/**
+ * Base error class for Trello CLI application
+ */
+import { t } from '@/i18n';
+
+export class TrelloCliError extends Error {
+  constructor(
+    message: string,
+    public readonly code: string,
+    public readonly statusCode?: number,
+  ) {
+    super(message);
+    this.name = this.constructor.name;
+  }
+}
+
+/**
+ * Authentication related errors
+ */
+export class AuthenticationError extends TrelloCliError {
+  constructor(message: string = 'Authentication failed') {
+    super(message, 'AUTH_ERROR', 401);
+  }
+}
+
+/**
+ * API related errors
+ */
+export class ApiError extends TrelloCliError {
+  constructor(
+    message: string,
+    override readonly statusCode: number,
+    public readonly endpoint?: string,
+  ) {
+    super(message, 'API_ERROR', statusCode);
+  }
+}
+
+/**
+ * Validation errors
+ */
+export class ValidationError extends TrelloCliError {
+  constructor(
+    message: string,
+    public readonly field?: string,
+  ) {
+    super(message, 'VALIDATION_ERROR', 400);
+  }
+}
+
+/**
+ * Resource not found errors
+ */
+export class NotFoundError extends TrelloCliError {
+  constructor(
+    message: string,
+    public readonly resourceType: string,
+    public readonly resourceId?: string,
+  ) {
+    super(message, 'NOT_FOUND_ERROR', 404);
+  }
+}
+
+/**
+ * Configuration errors
+ */
+export class ConfigurationError extends TrelloCliError {
+  constructor(message: string) {
+    super(message, 'CONFIG_ERROR', 500);
+  }
+}
+
+/**
+ * Network connectivity errors
+ */
+export class NetworkError extends TrelloCliError {
+  constructor(message: string = t('api.networkConnectionFailed')) {
+    super(message, 'NETWORK_ERROR', 0);
+  }
+}
+
+/**
+ * Error handler class for consistent error handling and user feedback
+ */
+export class ErrorHandler {
+  /**
+   * Handle an error and provide appropriate user feedback
+   */
+  static handle(error: unknown, context?: string): void {
+    if (error instanceof TrelloCliError) {
+      this.handleTrelloError(error, context);
+    } else if (error instanceof Error) {
+      this.handleGenericError(error, context);
+    } else {
+      this.handleUnknownError(error, context);
+    }
+  }
+
+  /**
+   * Handle Trello CLI specific errors
+   */
+  private static handleTrelloError(
+    error: TrelloCliError,
+    context?: string,
+  ): void {
+    const prefix = context ? `[${context}] ` : '';
+
+    switch (error.code) {
+      case 'AUTH_ERROR':
+        console.error(t('errors.authFailed', { message: error.message }));
+        console.error(t('errors.trySetup'));
+        break;
+
+      case 'API_ERROR':
+        console.error(
+          t('errors.apiError', { statusCode: error.statusCode, message: error.message }),
+        );
+        if (error instanceof ApiError && error.endpoint) {
+          console.error(t('errors.endpoint', { endpoint: error.endpoint }));
+        }
+        break;
+
+      case 'VALIDATION_ERROR':
+        console.error(t('errors.validationError', { message: error.message }));
+        if (error instanceof ValidationError && error.field) {
+          console.error(t('errors.field', { field: error.field }));
+        }
+        break;
+
+      case 'NOT_FOUND_ERROR':
+        console.error(t('errors.notFound', { message: error.message }));
+        if (error instanceof NotFoundError) {
+          if (error.resourceType) {
+            console.error(
+              t('errors.resourceType', { resourceType: error.resourceType }),
+            );
+          }
+          if (error.resourceId) {
+            console.error(
+              t('errors.resourceId', { resourceId: error.resourceId }),
+            );
+          }
+        }
+        break;
+
+      case 'CONFIG_ERROR':
+        console.error(t('errors.configError', { message: error.message }));
+        console.error(t('errors.checkConfig'));
+        break;
+
+      case 'NETWORK_ERROR':
+        console.error(t('errors.networkError', { message: error.message }));
+        console.error(t('errors.checkConnection'));
+        break;
+
+      default:
+        console.error(`❌ ${prefix}${error.message}`);
+    }
+
+    // Exit with appropriate code for automation
+    process.exit(error.statusCode || 1);
+  }
+
+  /**
+   * Handle generic JavaScript errors
+   */
+  private static handleGenericError(error: Error, _context?: string): void {
+    console.error(t('errors.unexpectedError', { message: error.message }));
+
+    // In development, show stack trace
+    if (process.env.NODE_ENV === 'development') {
+      console.error(t('errors.stackTrace'), error.stack);
+    }
+
+    process.exit(1);
+  }
+
+  /**
+   * Handle unknown errors
+   */
+  private static handleUnknownError(error: unknown, _context?: string): void {
+    console.error(t('errors.unknownError'), error);
+    process.exit(1);
+  }
+
+  /**
+   * Wrap async operations with error handling
+   */
+  static async withErrorHandling<T>(
+    operation: () => Promise<T>,
+    context?: string,
+  ): Promise<T> {
+    try {
+      return await operation();
+    } catch (error) {
+      this.handle(error, context);
+      // This line won't be reached due to process.exit, but TypeScript needs it
+      throw error;
+    }
+  }
+
+  /**
+   * Create user-friendly error messages from API responses
+   */
+  static fromApiResponse(
+    response: Record<string, unknown>,
+    endpoint?: string,
+  ): TrelloCliError {
+    const statusCode
+      = (response.status as number) || (response.statusCode as number) || 500;
+    const message
+      = (response.message as string)
+        || (response.error as string)
+        || t('api.unknownApiError');
+
+    switch (statusCode) {
+      case 401:
+        return new AuthenticationError(t('api.invalidToken'));
+      case 403:
+        return new AuthenticationError('Access denied');
+      case 404:
+        return new NotFoundError(t('api.resourceNotFound'), 'unknown');
+      case 400:
+        return new ValidationError(message);
+      case 429:
+        return new ApiError(t('api.rateLimitExceeded'), statusCode, endpoint);
+      case 500:
+        return new ApiError(t('api.internalServerError'), statusCode, endpoint);
+      default:
+        return new ApiError(message, statusCode, endpoint);
+    }
+  }
+}

package/src/shared/OutputFormatter.ts

@@ -0,0 +1,210 @@
+import { t } from '@/i18n';
+
+export type OutputFormat = 'table' | 'json' | 'csv';
+
+export interface OutputFormatterOptions {
+  format: OutputFormat;
+  headers?: string[];
+  fields?: string[];
+}
+
+export class OutputFormatter {
+  private format: OutputFormat;
+
+  constructor(format: OutputFormat = 'table') {
+    this.format = format;
+  }
+
+  setFormat(format: OutputFormat): void {
+    this.format = format;
+  }
+
+  /**
+   * Format and output data based on the current format
+   */
+  output<T>(data: T[] | T, options?: Partial<OutputFormatterOptions>): void {
+    const format = options?.format || this.format;
+
+    switch (format) {
+      case 'json':
+        this.outputJson(data);
+        break;
+      case 'csv':
+        this.outputCsv(data as T[], options);
+        break;
+      case 'table':
+      default:
+        this.outputTable(data as T[], options);
+        break;
+    }
+  }
+
+  /**
+   * Output data in JSON format
+   */
+  private outputJson<T>(data: T[] | T): void {
+    console.log(JSON.stringify(data, null, 2));
+  }
+
+  /**
+   * Output data in CSV format
+   */
+  private outputCsv<T>(
+    data: T[],
+    options?: Partial<OutputFormatterOptions>,
+  ): void {
+    if (!Array.isArray(data) || data.length === 0) {
+      console.log(t('common.noData'));
+      return;
+    }
+
+    const firstItem = data[0];
+    if (!firstItem) {
+      console.log(t('common.noData'));
+      return;
+    }
+
+    // Convert to plain object if it's a class instance
+    const plainItem = this.toPlainObject(firstItem);
+    const fields = options?.fields || Object.keys(plainItem);
+    const headers = options?.headers || fields;
+
+    // Output headers
+    console.log(headers.join(','));
+
+    // Output data rows
+    for (const item of data) {
+      const plainObject = this.toPlainObject(item);
+      const row = fields.map((field) => {
+        const value = plainObject[field];
+        // Escape commas and quotes in CSV
+        const stringValue = String(value || '');
+        if (
+          stringValue.includes(',')
+          || stringValue.includes('"')
+          || stringValue.includes('\n')
+        ) {
+          return `"${stringValue.replace(/"/g, '""')}"`;
+        }
+        return stringValue;
+      });
+      console.log(row.join(','));
+    }
+  }
+
+  /**
+   * Output data in table format (default)
+   */
+  private outputTable<T>(
+    data: T[],
+    options?: Partial<OutputFormatterOptions>,
+  ): void {
+    if (!Array.isArray(data) || data.length === 0) {
+      console.log(t('common.noData'));
+      return;
+    }
+
+    const firstItem = data[0];
+    if (!firstItem) {
+      console.log(t('common.noData'));
+      return;
+    }
+
+    // Convert to plain object if it's a class instance
+    const plainItem = this.toPlainObject(firstItem);
+    const fields = options?.fields || Object.keys(plainItem);
+    const headers = options?.headers || fields;
+
+    // Calculate column widths
+    const columnWidths = headers.map((header, index) => {
+      const field = fields[index]!;
+      const headerWidth = header.length;
+      const maxDataWidth = Math.max(
+        ...data.map((item) => {
+          const plainObject = this.toPlainObject(item);
+          return String(plainObject[field] || '').length;
+        }),
+      );
+      return Math.max(headerWidth, maxDataWidth);
+    });
+
+    // Output header
+    const headerRow = headers
+      .map((header, index) => header.padEnd(columnWidths[index]!))
+      .join(' | ');
+    console.log(headerRow);
+
+    // Output separator
+    const separator = columnWidths
+      .map(width => '-'.repeat(width))
+      .join('-+-');
+    console.log(separator);
+
+    // Output data rows
+    for (const item of data) {
+      const plainObject = this.toPlainObject(item);
+      const row = fields
+        .map((field, index) => {
+          const value = String(plainObject[field!] || '');
+          return value.padEnd(columnWidths[index]!);
+        })
+        .join(' | ');
+      console.log(row);
+    }
+  }
+
+  /**
+   * Convert an object to a plain object for serialization
+   */
+  private toPlainObject<T>(obj: T): Record<string, unknown> {
+    if (obj === null || obj === undefined) {
+      return {};
+    }
+
+    if (typeof obj === 'object' && obj.constructor !== Object) {
+      // It's a class instance, convert to plain object
+      const plain: Record<string, unknown> = {};
+      for (const key of Object.keys(obj as object)) {
+        plain[key] = (obj as Record<string, unknown>)[key];
+      }
+      return plain;
+    }
+
+    return obj as Record<string, unknown>;
+  }
+
+  /**
+   * Output a simple message
+   */
+  message(message: string): void {
+    console.log(message);
+  }
+
+  /**
+   * Output an error message
+   */
+  error(message: string): void {
+    console.error(`❌ ${message}`);
+  }
+
+  /**
+   * Output a success message
+   */
+  success(message: string): void {
+    console.log(`✅ ${message}`);
+  }
+
+  /**
+   * Output a warning message
+   */
+  warning(message: string): void {
+    console.log(`⚠️  ${message}`);
+  }
+
+  /**
+   * Output an info message
+   */
+  info(message: string): void {
+    console.log(`ℹ️  ${message}`);
+  }
+}

package/src/shared/index.ts

@@ -1 +1,3 @@
+export * from './ErrorHandler';
+export * from './OutputFormatter';
 export * from './types';