feat: enhance R2 object Get operation to download content with text/binary output options

ARHAEEM · ARHAEEM · commit 8bebe2e005ec · 2026-06-10T00:17:55.000+03:00
diff --git a/nodes/CloudflareR2/R2ObjectDescription.ts b/nodes/CloudflareR2/R2ObjectDescription.ts
@@ -22,7 +22,7 @@ export const r2ObjectOperations: INodeProperties[] = [
 			{
 				name: 'Get',
 				value: 'get',
-				description: 'Get object metadata',
+				description: "Download an object's content from a bucket",
 				action: 'Get an object',
 			},
 			{
@@ -95,6 +95,51 @@ export const r2ObjectFields: INodeProperties[] = [
 		},
 	},
 
+	// ===========================================
+	//         Get (download) fields
+	// ===========================================
+	{
+		displayName: 'Output Format',
+		name: 'responseFormat',
+		type: 'options',
+		displayOptions: {
+			show: {
+				resource: ['object'],
+				operation: ['get'],
+			},
+		},
+		options: [
+			{
+				name: 'Text',
+				value: 'text',
+				description: 'Return the object content as text inside the JSON output',
+			},
+			{
+				name: 'Binary File',
+				value: 'binary',
+				description: 'Return the object content as a downloadable binary property',
+			},
+		],
+		default: 'text',
+		description: 'How to return the downloaded object content',
+	},
+	{
+		displayName: 'Put Output In Field',
+		name: 'binaryPropertyName',
+		type: 'string',
+		required: true,
+		default: 'data',
+		placeholder: 'data',
+		description: 'Name of the binary property to write the downloaded file to',
+		displayOptions: {
+			show: {
+				resource: ['object'],
+				operation: ['get'],
+				responseFormat: ['binary'],
+			},
+		},
+	},
+
 	// ===========================================
 	//         Upload fields
 	// ===========================================
diff --git a/nodes/CloudflareR2/R2ObjectExecute.test.ts b/nodes/CloudflareR2/R2ObjectExecute.test.ts
@@ -3,19 +3,24 @@ import { r2ObjectExecute } from './R2ObjectExecute';
 import {
 	cloudflareApiRequest,
 	cloudflareApiRequestAllItems,
+	cloudflareApiRequestDownload,
 	cloudflareApiRequestRaw,
 } from '../shared/GenericFunctions';
 
 jest.mock('../shared/GenericFunctions', () => ({
 	cloudflareApiRequest: jest.fn(),
 	cloudflareApiRequestAllItems: jest.fn(),
+	cloudflareApiRequestDownload: jest.fn(),
 	cloudflareApiRequestRaw: jest.fn(),
 }));
 
 const mockCloudflareApiRequest = cloudflareApiRequest as jest.MockedFunction<typeof cloudflareApiRequest>;
 const mockCloudflareApiRequestAllItems = cloudflareApiRequestAllItems as jest.MockedFunction<
 	typeof cloudflareApiRequestAllItems
 >;
+const mockCloudflareApiRequestDownload = cloudflareApiRequestDownload as jest.MockedFunction<
+	typeof cloudflareApiRequestDownload
+>;
 const mockCloudflareApiRequestRaw = cloudflareApiRequestRaw as jest.MockedFunction<
 	typeof cloudflareApiRequestRaw
 >;
@@ -30,6 +35,11 @@ function createExecuteContext(
 		helpers: {
 			getBinaryDataBuffer: jest.fn(async () => binaryBuffer),
 			assertBinaryData: jest.fn(() => binaryData),
+			prepareBinaryData: jest.fn(async (data: Buffer, fileName: string, mimeType?: string) => ({
+				data: data.toString('base64'),
+				fileName,
+				mimeType: mimeType ?? 'application/octet-stream',
+			})),
 		},
 	} as unknown as IExecuteFunctions;
 }
@@ -190,3 +200,89 @@ describe('r2ObjectExecute upload', () => {
 		]);
 	});
 });
+
+describe('r2ObjectExecute get (download)', () => {
+	beforeEach(() => {
+		jest.clearAllMocks();
+	});
+
+	it('downloads object content and returns it as text by default', async () => {
+		mockCloudflareApiRequestDownload.mockResolvedValueOnce({
+			body: Buffer.from('# Hello\nWorld', 'utf-8'),
+			contentType: 'text/markdown',
+		});
+
+		const context = createExecuteContext({
+			operation: 'get',
+			accountId: 'acc123',
+			bucketName: 'my-bucket',
+			objectKey: 'docs/readme.md',
+			responseFormat: 'text',
+		});
+
+		const result = await r2ObjectExecute.call(context, 0);
+
+		expect(mockCloudflareApiRequestDownload).toHaveBeenCalledWith(
+			'GET',
+			'/accounts/acc123/r2/buckets/my-bucket/objects/docs%2Freadme.md',
+			{},
+			0,
+		);
+		expect(mockCloudflareApiRequest).not.toHaveBeenCalled();
+		expect(result).toEqual([
+			{
+				json: {
+					success: true,
+					key: 'docs/readme.md',
+					content: '# Hello\nWorld',
+					contentType: 'text/markdown',
+					size: Buffer.from('# Hello\nWorld', 'utf-8').length,
+				},
+				pairedItem: { item: 0 },
+			},
+		]);
+	});
+
+	it('returns object content as a binary property when requested', async () => {
+		const fileBytes = Buffer.from([0, 1, 2, 3, 4]);
+		mockCloudflareApiRequestDownload.mockResolvedValueOnce({
+			body: fileBytes,
+			contentType: 'application/octet-stream',
+		});
+
+		const context = createExecuteContext({
+			operation: 'get',
+			accountId: 'acc123',
+			bucketName: 'my-bucket',
+			objectKey: 'data/blob.bin',
+			responseFormat: 'binary',
+			binaryPropertyName: 'data',
+		});
+
+		const result = await r2ObjectExecute.call(context, 0);
+
+		expect(context.helpers.prepareBinaryData).toHaveBeenCalledWith(
+			fileBytes,
+			'data/blob.bin',
+			'application/octet-stream',
+		);
+		expect(result).toEqual([
+			{
+				json: {
+					success: true,
+					key: 'data/blob.bin',
+					contentType: 'application/octet-stream',
+					size: fileBytes.length,
+				},
+				binary: {
+					data: {
+						data: fileBytes.toString('base64'),
+						fileName: 'data/blob.bin',
+						mimeType: 'application/octet-stream',
+					},
+				},
+				pairedItem: { item: 0 },
+			},
+		]);
+	});
+});
diff --git a/nodes/CloudflareR2/R2ObjectExecute.ts b/nodes/CloudflareR2/R2ObjectExecute.ts
@@ -6,6 +6,7 @@ import {
 import {
 	cloudflareApiRequest,
 	cloudflareApiRequestAllItems,
+	cloudflareApiRequestDownload,
 	cloudflareApiRequestRaw,
 } from '../shared/GenericFunctions';
 
@@ -58,12 +59,47 @@ export async function r2ObjectExecute(
 
 	if (operation === 'get') {
 		const objectKey = this.getNodeParameter('objectKey', itemIndex) as string;
+		const responseFormat = this.getNodeParameter('responseFormat', itemIndex, 'text') as string;
 
-		responseData = await cloudflareApiRequest.call(
+		const { body, contentType } = await cloudflareApiRequestDownload.call(
 			this,
 			'GET',
 			`/accounts/${accountId}/r2/buckets/${bucketName}/objects/${encodeURIComponent(objectKey)}`,
+			{},
+			itemIndex,
 		);
+
+		if (responseFormat === 'binary') {
+			const binaryPropertyName = this.getNodeParameter('binaryPropertyName', itemIndex, 'data') as string;
+
+			const binaryData = await this.helpers.prepareBinaryData(body, objectKey, contentType);
+
+			return [
+				{
+					json: {
+						success: true,
+						key: objectKey,
+						contentType: contentType ?? binaryData.mimeType,
+						size: body.length,
+					},
+					binary: { [binaryPropertyName]: binaryData },
+					pairedItem: { item: itemIndex },
+				},
+			];
+		}
+
+		return [
+			{
+				json: {
+					success: true,
+					key: objectKey,
+					content: body.toString('utf-8'),
+					contentType: contentType ?? 'text/plain',
+					size: body.length,
+				},
+				pairedItem: { item: itemIndex },
+			},
+		];
 	}
 
 	if (operation === 'delete') {
diff --git a/nodes/CloudflareRulesets/RulesetDescription.ts b/nodes/CloudflareRulesets/RulesetDescription.ts
@@ -156,7 +156,8 @@ export const rulesetFields: INodeProperties[] = [
 			{ name: 'HTTP Request Firewall Managed', value: 'http_request_firewall_managed' },
 			{ name: 'HTTP Request Late Transform', value: 'http_request_late_transform' },
 			{ name: 'HTTP Request Origin', value: 'http_request_origin' },
-			{ name: 'HTTP Request Redirect', value: 'http_request_redirect' },
+			{ name: 'HTTP Request Dynamic Redirect (Single Redirects)', value: 'http_request_dynamic_redirect' },
+			{ name: 'HTTP Request Redirect (Bulk Redirects)', value: 'http_request_redirect' },
 			{ name: 'HTTP Request Sanitize', value: 'http_request_sanitize' },
 			{ name: 'HTTP Request Transform', value: 'http_request_transform' },
 			{ name: 'HTTP Response Firewall Managed', value: 'http_response_firewall_managed' },
diff --git a/nodes/shared/GenericFunctions.ts b/nodes/shared/GenericFunctions.ts
@@ -390,6 +390,100 @@ export async function cloudflareApiRequestRaw(
 	}
 }
 
+/**
+ * Download a raw/binary object from Cloudflare (e.g. R2 object content).
+ *
+ * Unlike `cloudflareApiRequest` (which expects a JSON `{ success, result }`
+ * envelope) this returns the raw bytes together with the response
+ * `Content-Type` so the caller can surface the data as text or as an n8n
+ * binary property. Used by the R2 object "Get" (download) operation.
+ */
+export async function cloudflareApiRequestDownload(
+	this: IExecuteFunctions,
+	method: IHttpRequestMethods,
+	endpoint: string,
+	qs: IDataObject = {},
+	itemIndex?: number,
+): Promise<{ body: Buffer; contentType?: string }> {
+	const options: IHttpRequestOptions = {
+		method,
+		url: `https://api.cloudflare.com/client/v4${endpoint}`,
+		encoding: 'arraybuffer',
+		returnFullResponse: true,
+		json: false,
+	};
+
+	if (Object.keys(qs).length > 0) {
+		options.qs = qs;
+	}
+
+	try {
+		const response = (await this.helpers.httpRequestWithAuthentication.call(
+			this,
+			'cloudflareApi',
+			options,
+		)) as { body?: unknown; headers?: IDataObject };
+
+		const rawBody = response.body;
+		let body: Buffer;
+		if (Buffer.isBuffer(rawBody)) {
+			body = rawBody;
+		} else if (rawBody instanceof ArrayBuffer) {
+			body = Buffer.from(new Uint8Array(rawBody));
+		} else if (rawBody instanceof Uint8Array) {
+			body = Buffer.from(rawBody);
+		} else if (typeof rawBody === 'string') {
+			body = Buffer.from(rawBody, 'utf-8');
+		} else {
+			body = Buffer.alloc(0);
+		}
+
+		const headers = (response.headers ?? {}) as IDataObject;
+		const contentType = headers['content-type'] as string | undefined;
+
+		return { body, contentType };
+	} catch (error) {
+		const err = error as {
+			statusCode?: number;
+			message?: string;
+			httpCode?: string;
+			response?: { body?: unknown };
+		};
+
+		// Cloudflare returns a JSON error envelope even for download endpoints.
+		let cfErrors: Array<{ message?: string; code?: number }> | undefined;
+		const errorBody = err.response?.body;
+		if (errorBody) {
+			let parsed: { errors?: Array<{ message?: string; code?: number }> } | undefined;
+			if (Buffer.isBuffer(errorBody)) {
+				try {
+					parsed = JSON.parse(errorBody.toString('utf-8'));
+				} catch {
+					// Ignore non-JSON error bodies
+				}
+			} else if (typeof errorBody === 'string') {
+				try {
+					parsed = JSON.parse(errorBody);
+				} catch {
+					// Ignore non-JSON error bodies
+				}
+			} else if (typeof errorBody === 'object') {
+				parsed = errorBody as { errors?: Array<{ message?: string; code?: number }> };
+			}
+			cfErrors = parsed?.errors;
+		}
+
+		const cfErrorMessage = cfErrors?.[0]?.message;
+		const httpCode = err.httpCode || (err.statusCode ? String(err.statusCode) : undefined);
+
+		throw new NodeApiError(this.getNode(), error as JsonObject, {
+			message: cfErrorMessage || err.message || 'Cloudflare object download failed',
+			httpCode,
+			itemIndex,
+		});
+	}
+}
+
 /**
  * Make an API request to Cloudflare with NDJSON body format
  * Used for Vectorize insert/upsert operations that require application/x-ndjson
