feat(plugin-dashboard): normalize string[] columns in ObjectDataTable

ObjectDataTable now supports both string[] shorthand and object[] formats
for column configuration. String entries like 'close_date' are auto-converted
to { header: 'Close Date', accessorKey: 'close_date' }. Handles snake_case,
camelCase, and mixed arrays. Fixes #303.

Co-authored-by: hotlong <50353452+hotlong@users.noreply.github.com>
Agent-Logs-Url: https://github.com/objectstack-ai/objectui/sessions/de8fa9da-2f3d-4641-b43f-330b65eee7db

Author: Copilot

CHANGELOG.md

@@ -9,6 +9,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
 
+- **ObjectDataTable: columns now support `string[]` shorthand** (`@object-ui/plugin-dashboard`): `ObjectDataTable` now normalizes `columns` entries so that both `string[]` (e.g. `['name', 'close_date']`) and `object[]` formats are accepted. String entries are automatically converted to `{ header, accessorKey }` objects with title-cased headers derived from snake_case and camelCase field names. Previously, passing a `string[]` caused the downstream `data-table` renderer to crash when accessing `col.accessorKey` on a plain string. Mixed arrays (some strings, some objects) are also handled correctly. Includes 8 new unit tests.
+
 - **i18n loadLanguage Not Compatible with Spec REST API Response Format** (`apps/console`): Fixed `loadLanguage` in `apps/console/src/main.tsx` to correctly unwrap the `@objectstack/spec` REST API envelope `{ data: { locale, translations } }`. Previously, the function returned the raw JSON response, which meant `useObjectLabel` and `useObjectTranslation` hooks received a wrapped object instead of the flat translation map, causing business object and field labels (e.g., CRM contact/account) to fall back to English. The fix extracts `data.translations` when the spec envelope is detected, while preserving backward compatibility with mock/dev environments that return flat translation objects. Includes 6 unit tests covering spec envelope unwrapping, flat fallback, HTTP errors, network failures, and edge cases.
 
 - **List Toolbar Action Buttons Not Responding** (`apps/console`): Fixed a bug where schema-driven action buttons in the upper-right corner of the list view (rendered via `action:bar` with `locations: ['list_toolbar']`) did not respond to clicks. The root cause: the console `ObjectView` component rendered these action buttons via `SchemaRenderer` without wrapping them in an `ActionProvider`. This caused `useAction()` to fall back to a local `ActionRunner` with no handlers, toast, confirmation, or navigation capabilities — so clicks executed silently with no visible effect. Added `ActionProvider` with proper handlers (toast via Sonner, confirmation dialog, navigation via React Router, param collection dialog, and a generic API handler) to the console `ObjectView`, following the same pattern already used in `RecordDetailView`. Includes 4 new integration tests validating the full action chain (render, confirm, execute, cancel).

packages/plugin-dashboard/src/ObjectDataTable.tsx

@@ -29,6 +29,32 @@ export interface ObjectDataTableProps {
   className?: string;
 }
 
+/**
+ * Normalize columns to support both string[] shorthand and object[] formats.
+ *
+ * - `string[]` entries are converted to `{ header, accessorKey }` objects,
+ *   handling both snake_case and camelCase for header generation.
+ * - Object entries are returned as-is.
+ */
+export function normalizeColumns(columns: any[]): any[] {
+  return columns.map((col) => {
+    if (typeof col === 'string') {
+      return {
+        header: col
+          // snake_case → spaces
+          .replace(/_/g, ' ')
+          // camelCase → spaces before uppercase letters
+          .replace(/([A-Z])/g, ' $1')
+          .trim()
+          // Title Case each word
+          .replace(/\b\w/g, (c: string) => c.toUpperCase()),
+        accessorKey: col,
+      };
+    }
+    return col;
+  });
+}
+
 /**
  * ObjectDataTable — Async-aware wrapper for data-table.
  *
@@ -101,7 +127,9 @@ export const ObjectDataTable: React.FC<ObjectDataTableProps> = ({ schema, dataSo
 
   // Auto-derive columns from data keys when none are provided
   const derivedColumns = useMemo(() => {
-    if (schema.columns && schema.columns.length > 0) return schema.columns;
+    if (schema.columns && schema.columns.length > 0) {
+      return normalizeColumns(schema.columns);
+    }
     if (finalData.length === 0) return [];
     // Exclude internal/private fields (prefixed with '_') from auto-derived columns
     const keys = Object.keys(finalData[0]).filter(k => !k.startsWith('_'));

packages/plugin-dashboard/src/__tests__/ObjectDataTable.test.tsx

@@ -9,7 +9,7 @@
 import { describe, it, expect, vi } from 'vitest';
 import { render, screen, waitFor } from '@testing-library/react';
 import React from 'react';
-import { ObjectDataTable } from '../ObjectDataTable';
+import { ObjectDataTable, normalizeColumns } from '../ObjectDataTable';
 import { SchemaRendererProvider } from '@object-ui/react';
 
 describe('ObjectDataTable', () => {
@@ -119,4 +119,93 @@ describe('ObjectDataTable', () => {
 
     expect(dataSource.find).not.toHaveBeenCalled();
   });
+
+  it('should normalize string[] columns without crashing', () => {
+    const schema = {
+      ...baseSchema,
+      columns: ['name', 'amount', 'close_date'],
+      data: [
+        { name: 'Deal A', amount: 1000, close_date: '2025-01-01' },
+        { name: 'Deal B', amount: 2000, close_date: '2025-06-01' },
+      ],
+    };
+
+    // Should not crash when columns are strings
+    const { container } = render(
+      <SchemaRendererProvider>
+        <ObjectDataTable schema={schema} />
+      </SchemaRendererProvider>,
+    );
+
+    expect(container).toBeDefined();
+  });
+
+  it('should pass through object[] columns unchanged', () => {
+    const schema = {
+      ...baseSchema,
+      columns: [
+        { header: 'Name', accessorKey: 'name' },
+        { header: 'Amount', accessorKey: 'amount' },
+      ],
+      data: [
+        { name: 'Deal A', amount: 1000 },
+      ],
+    };
+
+    const { container } = render(
+      <SchemaRendererProvider>
+        <ObjectDataTable schema={schema} />
+      </SchemaRendererProvider>,
+    );
+
+    expect(container).toBeDefined();
+  });
+});
+
+describe('normalizeColumns', () => {
+  it('should convert snake_case string to title-cased header', () => {
+    const result = normalizeColumns(['close_date']);
+    expect(result).toEqual([{ header: 'Close Date', accessorKey: 'close_date' }]);
+  });
+
+  it('should convert camelCase string to title-cased header', () => {
+    const result = normalizeColumns(['firstName']);
+    expect(result).toEqual([{ header: 'First Name', accessorKey: 'firstName' }]);
+  });
+
+  it('should convert simple string to capitalized header', () => {
+    const result = normalizeColumns(['name']);
+    expect(result).toEqual([{ header: 'Name', accessorKey: 'name' }]);
+  });
+
+  it('should handle multiple string columns', () => {
+    const result = normalizeColumns(['name', 'total_amount', 'createdAt']);
+    expect(result).toEqual([
+      { header: 'Name', accessorKey: 'name' },
+      { header: 'Total Amount', accessorKey: 'total_amount' },
+      { header: 'Created At', accessorKey: 'createdAt' },
+    ]);
+  });
+
+  it('should pass through object columns unchanged', () => {
+    const cols = [
+      { header: 'Custom Name', accessorKey: 'name' },
+      { header: 'Amount ($)', accessorKey: 'amount' },
+    ];
+    const result = normalizeColumns(cols);
+    expect(result).toEqual(cols);
+  });
+
+  it('should handle mixed string and object columns', () => {
+    const result = normalizeColumns([
+      'name',
+      { header: 'Custom Amount', accessorKey: 'amount' },
+      'close_date',
+    ]);
+    expect(result).toEqual([
+      { header: 'Name', accessorKey: 'name' },
+      { header: 'Custom Amount', accessorKey: 'amount' },
+      { header: 'Close Date', accessorKey: 'close_date' },
+    ]);
+  });
 });