pull:初次提交

n8n-n8n-1.109.2/packages/nodes-base/nodes/MoveBinaryData/MoveBinaryData.node.json

@@ -0,0 +1,17 @@
+{
+	"node": "n8n-nodes-base.moveBinaryData",
+	"nodeVersion": "1.0",
+	"codexVersion": "1.0",
+	"categories": ["Core Nodes"],
+	"resources": {
+		"primaryDocumentation": [
+			{
+				"url": "https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.converttofile/"
+			}
+		]
+	},
+	"subcategories": {
+		"Core Nodes": ["Files"]
+	},
+	"alias": ["Move Binary Data"]
+}

n8n-n8n-1.109.2/packages/nodes-base/nodes/MoveBinaryData/MoveBinaryData.node.ts

@@ -0,0 +1,488 @@
+import iconv from 'iconv-lite';
+import get from 'lodash/get';
+import set from 'lodash/set';
+import unset from 'lodash/unset';
+import type {
+	IExecuteFunctions,
+	IDataObject,
+	INodeExecutionData,
+	INodePropertyOptions,
+	INodeType,
+	INodeTypeDescription,
+} from 'n8n-workflow';
+import {
+	BINARY_ENCODING,
+	deepCopy,
+	jsonParse,
+	NodeConnectionTypes,
+	NodeOperationError,
+} from 'n8n-workflow';
+
+iconv.encodingExists('utf8');
+
+// Create options for bomAware and encoding
+const bomAware: string[] = [];
+const encodeDecodeOptions: INodePropertyOptions[] = [];
+const encodings = (iconv as any).encodings;
+Object.keys(encodings as IDataObject).forEach((encoding) => {
+	if (!(encoding.startsWith('_') || typeof encodings[encoding] === 'string')) {
+		// only encodings without direct alias or internals
+		if (encodings[encoding].bomAware) {
+			bomAware.push(encoding);
+		}
+		encodeDecodeOptions.push({ name: encoding, value: encoding });
+	}
+});
+
+encodeDecodeOptions.sort((a, b) => {
+	if (a.name < b.name) {
+		return -1;
+	}
+	if (a.name > b.name) {
+		return 1;
+	}
+	return 0;
+});
+
+export class MoveBinaryData implements INodeType {
+	description: INodeTypeDescription = {
+		hidden: true,
+		displayName: 'Convert to/from binary data',
+		name: 'moveBinaryData',
+		icon: 'fa:exchange-alt',
+		group: ['transform'],
+		version: [1, 1.1],
+		subtitle: '={{$parameter["mode"]==="binaryToJson" ? "Binary to JSON" : "JSON to Binary"}}',
+		description: 'Move data between binary and JSON properties',
+		defaults: {
+			name: 'Convert to/from binary data',
+			color: '#7722CC',
+		},
+		inputs: [NodeConnectionTypes.Main],
+		outputs: [NodeConnectionTypes.Main],
+		properties: [
+			{
+				displayName: 'Mode',
+				name: 'mode',
+				type: 'options',
+				options: [
+					{
+						name: 'Binary to JSON',
+						value: 'binaryToJson',
+						description: 'Move data from Binary to JSON',
+					},
+					{
+						name: 'JSON to Binary',
+						value: 'jsonToBinary',
+						description: 'Move data from JSON to Binary',
+					},
+				],
+				default: 'binaryToJson',
+				description: 'From and to where data should be moved',
+			},
+
+			// ----------------------------------
+			//         binaryToJson
+			// ----------------------------------
+			{
+				displayName: 'Set All Data',
+				name: 'setAllData',
+				type: 'boolean',
+				displayOptions: {
+					show: {
+						mode: ['binaryToJson'],
+					},
+				},
+				default: true,
+				description:
+					'Whether all JSON data should be replaced with the data retrieved from binary key. Else the data will be written to a single key.',
+			},
+			{
+				displayName: 'Source Key',
+				name: 'sourceKey',
+				type: 'string',
+				displayOptions: {
+					show: {
+						mode: ['binaryToJson'],
+					},
+				},
+				default: 'data',
+				required: true,
+				placeholder: 'data',
+				description:
+					'The name of the binary key to get data from. It is also possible to define deep keys by using dot-notation like for example: "level1.level2.currentKey".',
+			},
+			{
+				displayName: 'Destination Key',
+				name: 'destinationKey',
+				type: 'string',
+				displayOptions: {
+					show: {
+						mode: ['binaryToJson'],
+						setAllData: [false],
+					},
+				},
+				default: 'data',
+				required: true,
+				placeholder: '',
+				description:
+					'The name the JSON key to copy data to. It is also possible to define deep keys by using dot-notation like for example: "level1.level2.newKey".',
+			},
+
+			// ----------------------------------
+			//         jsonToBinary
+			// ----------------------------------
+			{
+				displayName: 'Convert All Data',
+				name: 'convertAllData',
+				type: 'boolean',
+				displayOptions: {
+					show: {
+						mode: ['jsonToBinary'],
+					},
+				},
+				default: true,
+				description:
+					'Whether all JSON data should be converted to binary. Else only the data of one key will be converted.',
+			},
+			{
+				displayName: 'Source Key',
+				name: 'sourceKey',
+				type: 'string',
+				displayOptions: {
+					show: {
+						convertAllData: [false],
+						mode: ['jsonToBinary'],
+					},
+				},
+				default: 'data',
+				required: true,
+				placeholder: 'data',
+				description:
+					'The name of the JSON key to get data from. It is also possible to define deep keys by using dot-notation like for example: "level1.level2.currentKey".',
+			},
+			{
+				displayName: 'Destination Key',
+				name: 'destinationKey',
+				type: 'string',
+				displayOptions: {
+					show: {
+						mode: ['jsonToBinary'],
+					},
+				},
+				default: 'data',
+				required: true,
+				placeholder: 'data',
+				description:
+					'The name the binary key to copy data to. It is also possible to define deep keys by using dot-notation like for example: "level1.level2.newKey".',
+			},
+
+			{
+				displayName: 'Options',
+				name: 'options',
+				type: 'collection',
+				placeholder: 'Add option',
+				default: {},
+				options: [
+					{
+						displayName: 'Add Byte Order Mark (BOM)',
+						name: 'addBOM',
+						description:
+							'Whether to add special marker at the start of your text file. This marker helps some programs understand how to read the file correctly.',
+						displayOptions: {
+							show: {
+								'/mode': ['jsonToBinary'],
+								encoding: bomAware,
+							},
+						},
+						type: 'boolean',
+						default: false,
+					},
+					{
+						displayName: 'Data Is Base64',
+						name: 'dataIsBase64',
+						type: 'boolean',
+						displayOptions: {
+							hide: {
+								useRawData: [true],
+							},
+							show: {
+								'/mode': ['jsonToBinary'],
+								'/convertAllData': [false],
+							},
+						},
+						default: false,
+						description: 'Whether to keep the binary data as base64 string',
+					},
+					{
+						displayName: 'Encoding',
+						name: 'encoding',
+						type: 'options',
+						options: encodeDecodeOptions,
+						displayOptions: {
+							show: {
+								'/mode': ['binaryToJson', 'jsonToBinary'],
+							},
+						},
+						default: 'utf8',
+						description: 'Choose the character set to use to encode the data',
+					},
+					{
+						displayName: 'Strip BOM',
+						name: 'stripBOM',
+						displayOptions: {
+							show: {
+								'/mode': ['binaryToJson'],
+								encoding: bomAware,
+							},
+						},
+						type: 'boolean',
+						default: true,
+					},
+					{
+						displayName: 'File Name',
+						name: 'fileName',
+						type: 'string',
+						displayOptions: {
+							show: {
+								'/mode': ['jsonToBinary'],
+							},
+						},
+						default: '',
+						placeholder: 'example.json',
+						description: 'The file name to set',
+					},
+					{
+						displayName: 'JSON Parse',
+						name: 'jsonParse',
+						type: 'boolean',
+						displayOptions: {
+							hide: {
+								keepAsBase64: [true],
+							},
+							show: {
+								'/mode': ['binaryToJson'],
+								'/setAllData': [false],
+							},
+						},
+						default: false,
+						description: 'Whether to run JSON parse on the data to get proper object data',
+					},
+					{
+						displayName: 'Keep Source',
+						name: 'keepSource',
+						type: 'boolean',
+						default: false,
+						description: 'Whether the source key should be kept. By default it will be deleted.',
+					},
+					{
+						displayName: 'Keep As Base64',
+						name: 'keepAsBase64',
+						type: 'boolean',
+						displayOptions: {
+							hide: {
+								jsonParse: [true],
+							},
+							show: {
+								'/mode': ['binaryToJson'],
+								'/setAllData': [false],
+							},
+						},
+						default: false,
+						description: 'Whether to keep the binary data as base64 string',
+					},
+					{
+						displayName: 'MIME Type',
+						name: 'mimeType',
+						type: 'string',
+						displayOptions: {
+							show: {
+								'/mode': ['jsonToBinary'],
+							},
+						},
+						default: 'application/json',
+						placeholder: 'application/json',
+						description: 'The mime-type to set. By default will the mime-type for JSON be set.',
+					},
+					{
+						displayName: 'Use Raw Data',
+						name: 'useRawData',
+						type: 'boolean',
+						displayOptions: {
+							hide: {
+								dataIsBase64: [true],
+							},
+							show: {
+								'/mode': ['jsonToBinary'],
+							},
+						},
+						default: false,
+						description: 'Whether to use data as is and do not JSON.stringify it',
+					},
+				],
+			},
+		],
+	};
+
+	async execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
+		const items = this.getInputData();
+		const mode = this.getNodeParameter('mode', 0) as string;
+		const returnData: INodeExecutionData[] = [];
+
+		let item: INodeExecutionData;
+		let newItem: INodeExecutionData;
+		let options: IDataObject;
+		for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
+			item = items[itemIndex];
+			options = this.getNodeParameter('options', itemIndex, {});
+
+			// Copy the whole JSON data as data on any level can be renamed
+			newItem = {
+				json: {},
+				pairedItem: {
+					item: itemIndex,
+				},
+			};
+
+			if (mode === 'binaryToJson') {
+				const setAllData = this.getNodeParameter('setAllData', itemIndex) as boolean;
+				const sourceKey = this.getNodeParameter('sourceKey', itemIndex) as string;
+
+				const value = get(item.binary, sourceKey);
+
+				if (value === undefined) {
+					// No data found so skip
+					continue;
+				}
+
+				const encoding = (options.encoding as string) || 'utf8';
+
+				const buffer = await this.helpers.getBinaryDataBuffer(itemIndex, sourceKey);
+
+				let convertedValue: string;
+
+				if (setAllData) {
+					// Set the full data
+					convertedValue = iconv.decode(buffer, encoding, {
+						stripBOM: options.stripBOM as boolean,
+					});
+					newItem.json = jsonParse(convertedValue);
+				} else {
+					// Does get added to existing data so copy it first
+					newItem.json = deepCopy(item.json);
+
+					if (options.keepAsBase64 !== true) {
+						convertedValue = iconv.decode(buffer, encoding, {
+							stripBOM: options.stripBOM as boolean,
+						});
+					} else {
+						convertedValue = Buffer.from(buffer).toString(BINARY_ENCODING);
+					}
+
+					if (options.jsonParse) {
+						convertedValue = jsonParse(convertedValue);
+					}
+
+					const destinationKey = this.getNodeParameter('destinationKey', itemIndex, '') as string;
+					set(newItem.json, destinationKey, convertedValue);
+				}
+
+				if (options.keepSource === true) {
+					// Binary data does not get touched so simply reference it
+					newItem.binary = item.binary;
+				} else {
+					// Binary data will change so copy it
+					newItem.binary = deepCopy(item.binary);
+					unset(newItem.binary, sourceKey);
+				}
+			} else if (mode === 'jsonToBinary') {
+				const convertAllData = this.getNodeParameter('convertAllData', itemIndex) as boolean;
+				const destinationKey = this.getNodeParameter('destinationKey', itemIndex) as string;
+
+				const encoding = (options.encoding as string) || 'utf8';
+				let value: IDataObject | string = item.json;
+				if (!convertAllData) {
+					const sourceKey = this.getNodeParameter('sourceKey', itemIndex) as string;
+					value = get(item.json, sourceKey) as IDataObject;
+				}
+
+				if (value === undefined) {
+					// No data found so skip
+					continue;
+				}
+
+				if (item.binary !== undefined) {
+					// Item already has binary data so copy it
+					newItem.binary = deepCopy(item.binary);
+				} else {
+					// Item does not have binary data yet so initialize empty
+					newItem.binary = {};
+				}
+
+				const nodeVersion = this.getNode().typeVersion;
+				let mimeType = options.mimeType as string;
+
+				let data: Buffer;
+				if (options.dataIsBase64 !== true) {
+					if (options.useRawData !== true || typeof value === 'object') {
+						value = JSON.stringify(value);
+
+						if (!mimeType) {
+							mimeType = 'application/json';
+						}
+					}
+
+					data = iconv.encode(value, encoding, { addBOM: options.addBOM as boolean });
+				} else {
+					data = Buffer.from(value as unknown as string, BINARY_ENCODING);
+				}
+
+				if (!mimeType && nodeVersion === 1) {
+					mimeType = 'application/json';
+				}
+
+				const convertedValue = await this.helpers.prepareBinaryData(
+					data,
+					options.fileName as string,
+					mimeType,
+				);
+
+				if (!convertedValue.fileName && nodeVersion > 1) {
+					const fileExtension = convertedValue.fileExtension
+						? `.${convertedValue.fileExtension}`
+						: '';
+					convertedValue.fileName = `file${fileExtension}`;
+				}
+
+				set(newItem.binary, destinationKey, convertedValue);
+
+				if (options.keepSource === true) {
+					// JSON data does not get touched so simply reference it
+					newItem.json = item.json;
+				} else {
+					// JSON data will change so copy it
+
+					if (convertAllData) {
+						// Data should not be kept and all data got converted. So simply set new as empty
+						newItem.json = {};
+					} else {
+						// Data should not be kept and only one key has to get removed. So copy all
+						// data and then remove the not needed one
+						newItem.json = deepCopy(item.json);
+						const sourceKey = this.getNodeParameter('sourceKey', itemIndex) as string;
+
+						unset(newItem.json, sourceKey);
+					}
+				}
+			} else {
+				throw new NodeOperationError(this.getNode(), `The operation "${mode}" is not known!`, {
+					itemIndex,
+				});
+			}
+
+			returnData.push(newItem);
+		}
+
+		return [returnData];
+	}
+}

n8n-n8n-1.109.2/packages/nodes-base/nodes/MoveBinaryData/test/MoveBinaryData.test.ts

@@ -0,0 +1,115 @@
+import { NodeTestHarness } from '@nodes-testing/node-test-harness';
+import type { WorkflowTestData } from 'n8n-workflow';
+import path from 'path';
+
+describe('Test Move Binary Data Node', () => {
+	const testHarness = new NodeTestHarness();
+	const workflowData = testHarness.readWorkflowJSON('MoveBinaryData.workflow.json');
+	const node = workflowData.nodes.find((n) => n.name === 'Read Binary File')!;
+	node.parameters.filePath = path.join(__dirname, 'data', 'sample.json');
+
+	const tests: WorkflowTestData[] = [
+		{
+			description: 'nodes/MoveBinaryData/test/MoveBinaryData.workflow.json',
+			input: {
+				workflowData,
+			},
+			output: {
+				assertBinaryData: true,
+				nodeData: {
+					'Binary to JSON': [
+						[
+							{
+								json: {
+									id: 1,
+									title: 'My Title',
+									description: 'Lorem Ipsum ...',
+								},
+							},
+						],
+					],
+					'Binary to JSON - No Set All Data': [
+						[
+							{
+								json: {
+									data: '{\n\t"id": 1,\n\t"title": "My Title",\n\t"description": "Lorem Ipsum ..."\n}',
+								},
+							},
+						],
+					],
+					'Binary to JSON - No Set All Data + Json Parse': [
+						[
+							{
+								json: {
+									data: {
+										id: 1,
+										title: 'My Title',
+										description: 'Lorem Ipsum ...',
+									},
+								},
+							},
+						],
+					],
+					'Binary to JSON - No Set All Data + Encoding base64': [
+						[
+							{
+								json: {
+									data: 'ewoJImlkIjogMSwKCSJ0aXRsZSI6ICJNeSBUaXRsZSIsCgkiZGVzY3JpcHRpb24iOiAiTG9yZW0gSXBzdW0gLi4uIgp9',
+								},
+							},
+						],
+					],
+					'Binary to JSON - Keep as Base64': [
+						[
+							{
+								json: {
+									data: 'ewoJImlkIjogMSwKCSJ0aXRsZSI6ICJNeSBUaXRsZSIsCgkiZGVzY3JpcHRpb24iOiAiTG9yZW0gSXBzdW0gLi4uIgp9',
+								},
+							},
+						],
+					],
+					'JSON to Binary': [
+						[
+							{
+								json: {},
+								binary: {
+									data: {
+										data: 'eyJpZCI6MSwidGl0bGUiOiJNeSBUaXRsZSIsImRlc2NyaXB0aW9uIjoiTG9yZW0gSXBzdW0gLi4uIn0=',
+										mimeType: 'application/json',
+										fileType: 'json',
+										fileSize: '59 B',
+										fileExtension: 'json',
+									},
+								},
+							},
+						],
+					],
+					'JSON to Binary - No Convert All Data': [
+						[
+							{
+								json: {
+									id: 1,
+									description: 'Lorem Ipsum ...',
+								},
+								binary: {
+									data: {
+										data: 'Ik15IFRpdGxlIg==',
+										mimeType: 'application/json',
+										fileType: 'json',
+										fileSize: '10 B',
+										fileName: 'example.json',
+										fileExtension: 'json',
+									},
+								},
+							},
+						],
+					],
+				},
+			},
+		},
+	];
+
+	for (const testData of tests) {
+		testHarness.setupTest(testData);
+	}
+});

n8n-n8n-1.109.2/packages/nodes-base/nodes/MoveBinaryData/test/MoveBinaryData.workflow.json

@@ -0,0 +1,171 @@
+{
+	"meta": {
+		"instanceId": "104a4d08d8897b8bdeb38aaca515021075e0bd8544c983c2bb8c86e6a8e6081c"
+	},
+	"nodes": [
+		{
+			"parameters": {},
+			"id": "f1789069-98a9-44ad-8e72-6b5c4a000f51",
+			"name": "When clicking \"Execute Workflow\"",
+			"type": "n8n-nodes-base.manualTrigger",
+			"typeVersion": 1,
+			"position": [0, 1120]
+		},
+		{
+			"parameters": {
+				"filePath": "C:\\Test\\sample.json"
+			},
+			"id": "ef780d51-664d-4d8a-b0c1-43fe63921e82",
+			"name": "Read Binary File",
+			"type": "n8n-nodes-base.readBinaryFile",
+			"typeVersion": 1,
+			"position": [220, 1120]
+		},
+		{
+			"parameters": {
+				"setAllData": false,
+				"options": {}
+			},
+			"id": "1dfba9d4-dc39-4693-9411-405e423b8da8",
+			"name": "Binary to JSON - No Set All Data",
+			"type": "n8n-nodes-base.moveBinaryData",
+			"typeVersion": 1,
+			"position": [440, 1120]
+		},
+		{
+			"parameters": {
+				"options": {}
+			},
+			"id": "b745f52d-3a5f-4f42-b3d0-e303d3aded4c",
+			"name": "Binary to JSON",
+			"type": "n8n-nodes-base.moveBinaryData",
+			"typeVersion": 1,
+			"position": [440, 920]
+		},
+		{
+			"parameters": {
+				"mode": "jsonToBinary",
+				"options": {}
+			},
+			"id": "fb1bbc87-8b6c-4889-a376-760dbb8a090e",
+			"name": "JSON to Binary",
+			"type": "n8n-nodes-base.moveBinaryData",
+			"typeVersion": 1,
+			"position": [740, 780]
+		},
+		{
+			"parameters": {
+				"mode": "jsonToBinary",
+				"convertAllData": false,
+				"sourceKey": "title",
+				"options": {
+					"fileName": "example.json"
+				}
+			},
+			"id": "34ff0af3-fd2d-4b26-9e92-176f1aaff11a",
+			"name": "JSON to Binary - No Convert All Data",
+			"type": "n8n-nodes-base.moveBinaryData",
+			"typeVersion": 1,
+			"position": [740, 1020]
+		},
+		{
+			"parameters": {
+				"setAllData": false,
+				"options": {
+					"jsonParse": true
+				}
+			},
+			"id": "b2c37763-801b-497f-b7d8-4c30b7e108e7",
+			"name": "Binary to JSON - No Set All Data + Json Parse",
+			"type": "n8n-nodes-base.moveBinaryData",
+			"typeVersion": 1,
+			"position": [440, 1340]
+		},
+		{
+			"parameters": {
+				"setAllData": false,
+				"options": {
+					"encoding": "base64"
+				}
+			},
+			"id": "b2125e40-9cd6-4730-b243-30aa565a42ee",
+			"name": "Binary to JSON - No Set All Data + Encoding base64",
+			"type": "n8n-nodes-base.moveBinaryData",
+			"typeVersion": 1,
+			"position": [440, 1560]
+		},
+		{
+			"parameters": {
+				"setAllData": false,
+				"options": {
+					"keepAsBase64": true
+				}
+			},
+			"id": "30b27ae6-29e1-43c6-be10-1f17cb3ade8a",
+			"name": "Binary to JSON - Keep as Base64",
+			"type": "n8n-nodes-base.moveBinaryData",
+			"typeVersion": 1,
+			"position": [440, 1780]
+		}
+	],
+	"connections": {
+		"When clicking \"Execute Workflow\"": {
+			"main": [
+				[
+					{
+						"node": "Read Binary File",
+						"type": "main",
+						"index": 0
+					}
+				]
+			]
+		},
+		"Read Binary File": {
+			"main": [
+				[
+					{
+						"node": "Binary to JSON",
+						"type": "main",
+						"index": 0
+					},
+					{
+						"node": "Binary to JSON - No Set All Data",
+						"type": "main",
+						"index": 0
+					},
+					{
+						"node": "Binary to JSON - No Set All Data + Json Parse",
+						"type": "main",
+						"index": 0
+					},
+					{
+						"node": "Binary to JSON - No Set All Data + Encoding base64",
+						"type": "main",
+						"index": 0
+					},
+					{
+						"node": "Binary to JSON - Keep as Base64",
+						"type": "main",
+						"index": 0
+					}
+				]
+			]
+		},
+		"Binary to JSON": {
+			"main": [
+				[
+					{
+						"node": "JSON to Binary",
+						"type": "main",
+						"index": 0
+					},
+					{
+						"node": "JSON to Binary - No Convert All Data",
+						"type": "main",
+						"index": 0
+					}
+				]
+			]
+		}
+	}
+}

n8n-n8n-1.109.2/packages/nodes-base/nodes/MoveBinaryData/test/data/sample.json

@@ -0,0 +1,5 @@
+{
+	"id": 1,
+	"title": "My Title",
+	"description": "Lorem Ipsum ..."
+}