feat(editor): CSV download support for data tables

packages/cli/src/modules/data-table/data-table.controller.ts

@@ -261,6 +261,36 @@ export class DataTableController {
 		}
 	}
 
+	@Get('/:dataTableId/download-csv')
+	@ProjectScope('dataTable:read')
+	async downloadDataTableCsv(
+		req: AuthenticatedRequest<{ projectId: string; dataTableId: string }>,
+		_res: Response,
+	) {
+		try {
+			const { projectId, dataTableId } = req.params;
+
+			// Generate CSV content - this will validate that the table exists
+			const { csvContent, dataTableName } = await this.dataTableService.generateDataTableCsv(
+				dataTableId,
+				projectId,
+			);
+
+			return {
+				csvContent,
+				dataTableName,
+			};
+		} catch (e: unknown) {
+			if (e instanceof DataTableNotFoundError) {
+				throw new NotFoundError(e.message);
+			} else if (e instanceof Error) {
+				throw new InternalServerError(e.message, e);
+			} else {
+				throw e;
+			}
+		}
+	}
+
 	/**
 	 * @returns the IDs of the inserted rows
 	 */

packages/cli/src/modules/data-table/data-table.service.ts

@@ -688,4 +688,115 @@ export class DataTableService {
 			dataTables: accessibleDataTables,
 		};
 	}
+
+	async generateDataTableCsv(
+		dataTableId: string,
+		projectId: string,
+	): Promise<{ csvContent: string; dataTableName: string }> {
+		const dataTable = await this.validateDataTableExists(dataTableId, projectId);
+
+		// Fetch columns (ordered by index)
+		const columns = await this.dataTableColumnRepository.getColumns(dataTableId);
+
+		// Fetch ALL rows (no pagination for export)
+		const { data: rows } = await this.dataTableRowsRepository.getManyAndCount(
+			dataTableId,
+			{
+				skip: 0,
+				take: -1, // Get all rows
+			},
+			columns,
+		);
+
+		// Build CSV
+		const csvContent = this.buildCsvContent(rows, columns);
+
+		return {
+			csvContent,
+			dataTableName: dataTable.name,
+		};
+	}
+
+	private buildCsvContent(rows: DataTableRowReturn[], columns: DataTableColumn[]): string {
+		// Sort columns once to avoid repeated sorting in the row loop
+		const sortedColumns = [...columns].sort((a, b) => a.index - b.index);
+
+		// Build header row: id + user columns + createdAt/updatedAt at the end
+		const userHeaders = sortedColumns.map((col) => col.name);
+		const headers = ['id', ...userHeaders, 'createdAt', 'updatedAt'];
+
+		// Escape and join headers
+		const csvRows: string[] = [headers.map((h) => this.escapeCsvValue(h)).join(',')];
+
+		// Build data rows
+		for (const row of rows) {
+			const values: string[] = [];
+
+			// Add id first
+			values.push(this.escapeCsvValue(row.id));
+
+			// Add user column values (in correct order)
+			for (const column of sortedColumns) {
+				const value = row[column.name];
+				values.push(this.escapeCsvValue(this.formatValueForCsv(value, column.type)));
+			}
+
+			// Add createdAt and updatedAt at the end
+			values.push(this.escapeCsvValue(this.formatDateForCsv(row.createdAt)));
+			values.push(this.escapeCsvValue(this.formatDateForCsv(row.updatedAt)));
+
+			csvRows.push(values.join(','));
+		}
+
+		return csvRows.join('\n');
+	}
+
+	private formatValueForCsv(value: unknown, columnType: DataTableColumnType): string {
+		// Handle NULL/undefined
+		if (value === null || value === undefined) {
+			return '';
+		}
+
+		// Handle dates - always use ISO format for CSV
+		if (columnType === 'date') {
+			if (value instanceof Date || typeof value === 'string') {
+				return this.formatDateForCsv(value);
+			}
+		}
+
+		// Handle booleans - already normalized to true/false by normalizeRows
+		if (columnType === 'boolean') {
+			return String(value);
+		}
+
+		// Handle numbers
+		if (columnType === 'number') {
+			return String(value);
+		}
+
+		// Handle strings and everything else
+		return String(value);
+	}
+
+	private formatDateForCsv(date: Date | string): string {
+		if (date instanceof Date) {
+			return date.toISOString();
+		}
+		// If it's already a string, try to parse and format
+		const parsed = new Date(date);
+		return !isNaN(parsed.getTime()) ? parsed.toISOString() : String(date);
+	}
+
+	private escapeCsvValue(value: unknown): string {
+		const str = String(value);
+
+		// RFC 4180 compliant escaping:
+		// - If value contains comma, quote, or newline, wrap in quotes
+		// - Escape quotes by doubling them
+		if (str.includes(',') || str.includes('"') || str.includes('\n') || str.includes('\r')) {
+			return `"${str.replace(/"/g, '""')}"`;
+		}
+
+		return str;
+	}
 }

packages/frontend/@n8n/i18n/src/locales/en.json

@@ -3288,6 +3288,8 @@
 	"dataTable.import.invalidColumnName": "Only alphabetical and non-leading numbers and underscores allowed",
 	"dataTable.delete.confirm.message": "Are you sure you want to delete the data table '{name}'? This action cannot be undone.",
 	"dataTable.delete.error": "Error deleting data table",
+	"dataTable.download.csv": "Download CSV",
+	"dataTable.download.error": "Failed to download data table",
 	"dataTable.rename.error": "Error renaming data table",
 	"dataTable.getDetails.error": "Error fetching data table details",
 	"dataTable.notFound": "Data table not found",

packages/frontend/editor-ui/src/features/core/dataTable/components/DataTableActions.vue

@@ -40,6 +40,11 @@ const telemetry = useTelemetry();
 
 const actions = computed<Array<UserAction<IUser>>>(() => {
 	const availableActions = [
+		{
+			label: i18n.baseText('dataTable.download.csv'),
+			value: DATA_TABLE_CARD_ACTIONS.DOWNLOAD_CSV,
+			disabled: false,
+		},
 		{
 			label: i18n.baseText('generic.delete'),
 			value: DATA_TABLE_CARD_ACTIONS.DELETE,
@@ -67,6 +72,10 @@ const onAction = async (action: string) => {
 			});
 			break;
 		}
+		case DATA_TABLE_CARD_ACTIONS.DOWNLOAD_CSV: {
+			await downloadDataTableCsv();
+			break;
+		}
 		case DATA_TABLE_CARD_ACTIONS.DELETE: {
 			const promptResponse = await message.confirm(
 				i18n.baseText('dataTable.delete.confirm.message', {
@@ -86,6 +95,19 @@ const onAction = async (action: string) => {
 	}
 };
 
+const downloadDataTableCsv = async () => {
+	try {
+		await dataTableStore.downloadDataTableCsv(props.dataTable.id, props.dataTable.projectId);
+
+		telemetry.track('User downloaded data table CSV', {
+			data_table_id: props.dataTable.id,
+			data_table_project_id: props.dataTable.projectId,
+		});
+	} catch (error) {
+		toast.showError(error, i18n.baseText('dataTable.download.error'));
+	}
+};
+
 const deleteDataTable = async () => {
 	try {
 		const deleted = await dataTableStore.deleteDataTable(

packages/frontend/editor-ui/src/features/core/dataTable/constants.ts

@@ -21,6 +21,7 @@ export const DATA_TABLE_CARD_ACTIONS = {
 	RENAME: 'rename',
 	DELETE: 'delete',
 	CLEAR: 'clear',
+	DOWNLOAD_CSV: 'download-csv',
 };
 
 export const ADD_DATA_TABLE_MODAL_KEY = 'addDataTableModal';

packages/frontend/editor-ui/src/features/core/dataTable/dataTable.api.ts

@@ -223,6 +223,25 @@ export const fetchDataTableGlobalLimitInBytes = async (context: IRestApiContext)
 	);
 };
 
+export const downloadDataTableCsvApi = async (
+	context: IRestApiContext,
+	dataTableId: string,
+	projectId: string,
+): Promise<{ csvContent: string; filename: string }> => {
+	const response = await makeRestApiRequest<{ csvContent: string; dataTableName: string }>(
+		context,
+		'GET',
+		`/projects/${projectId}/data-tables/${dataTableId}/download-csv`,
+	);
+
+	// Use just the data table name as filename
+	const filename = `${response.dataTableName}.csv`;
+
+	return {
+		csvContent: response.csvContent,
+		filename,
+	};
+};
 export const uploadCsvFileApi = async (
 	context: IRestApiContext,
 	file: File,

packages/frontend/editor-ui/src/features/core/dataTable/dataTable.store.ts

@@ -15,6 +15,7 @@ import {
 	updateDataTableRowsApi,
 	deleteDataTableRowsApi,
 	fetchDataTableGlobalLimitInBytes,
+	downloadDataTableCsvApi,
 	uploadCsvFileApi,
 } from '@/features/core/dataTable/dataTable.api';
 import type {
@@ -273,6 +274,36 @@ export const useDataTableStore = defineStore(DATA_TABLE_STORE, () => {
 		return result;
 	};
 
+	const downloadDataTableCsv = async (dataTableId: string, projectId: string) => {
+		// Fetch CSV content with authentication
+		const { csvContent, filename } = await downloadDataTableCsvApi(
+			rootStore.restApiContext,
+			dataTableId,
+			projectId,
+		);
+
+		// Create blob with UTF-8 BOM for Excel compatibility
+		const bom = '\uFEFF';
+		const blob = new Blob([bom + csvContent], { type: 'text/csv;charset=utf-8;' });
+		const url = URL.createObjectURL(blob);
+
+		const tempElement = document.createElement('a');
+		tempElement.setAttribute('href', url);
+		tempElement.setAttribute('download', filename);
+		tempElement.style.display = 'none';
+		document.body.appendChild(tempElement);
+
+		try {
+			tempElement.click();
+		} finally {
+			// Ensure cleanup happens even if click fails
+			if (document.body.contains(tempElement)) {
+				document.body.removeChild(tempElement);
+			}
+			URL.revokeObjectURL(url);
+		}
+	};
+
 	return {
 		dataTables,
 		totalCount,
@@ -295,6 +326,7 @@ export const useDataTableStore = defineStore(DATA_TABLE_STORE, () => {
 		insertEmptyRow,
 		updateRow,
 		deleteRows,
+		downloadDataTableCsv,
 		projectPermissions,
 	};
 });