@fsai-flow/core 0.0.1

package/src/lib/index.ts

@@ -0,0 +1,187 @@
+import { IBinaryData, INodeExecutionData } from '@fsai-flow/workflow';
+import { BINARY_ENCODING } from './Constants';
+import { IBinaryDataConfig, IBinaryDataManager } from './Interfaces';
+import { BinaryDataFileSystem } from './FileSystem';
+
+export class BinaryDataManager {
+	private static instance: BinaryDataManager;
+
+	private managers: {
+		[key: string]: IBinaryDataManager;
+	};
+
+	private binaryDataMode: string;
+
+	private availableModes: string[];
+
+	constructor(config: IBinaryDataConfig) {
+		this.binaryDataMode = config.mode;
+		this.availableModes = config.availableModes.split(',');
+		this.managers = {};
+	}
+
+	static async init(config: IBinaryDataConfig, mainManager = false): Promise<void> {
+		if (BinaryDataManager.instance) {
+			throw new Error('Binary Data Manager already initialized');
+		}
+
+		BinaryDataManager.instance = new BinaryDataManager(config);
+
+		if (BinaryDataManager.instance.availableModes.includes('filesystem')) {
+			BinaryDataManager.instance.managers['filesystem'] = new BinaryDataFileSystem(config);
+			await BinaryDataManager.instance.managers['filesystem'].init(mainManager);
+		}
+
+		return undefined;
+	}
+
+	static getInstance(): BinaryDataManager {
+		if (!BinaryDataManager.instance) {
+			throw new Error('Binary Data Manager not initialized');
+		}
+
+		return BinaryDataManager.instance;
+	}
+
+	async storeBinaryData(
+		binaryData: IBinaryData,
+		binaryBuffer: Buffer,
+		executionId: string,
+	): Promise<IBinaryData> {
+		const retBinaryData = binaryData;
+
+		if (this.managers[this.binaryDataMode]) {
+			return this.managers[this.binaryDataMode]
+				.storeBinaryData(binaryBuffer, executionId)
+				.then((filename) => {
+					retBinaryData.id = this.generateBinaryId(filename);
+					return retBinaryData;
+				});
+		}
+
+		retBinaryData.data = binaryBuffer.toString(BINARY_ENCODING);
+		return binaryData;
+	}
+
+	async retrieveBinaryData(binaryData: IBinaryData): Promise<Buffer> {
+		if (binaryData.id) {
+			return this.retrieveBinaryDataByIdentifier(binaryData.id);
+		}
+
+		return Buffer.from(binaryData.data, BINARY_ENCODING);
+	}
+
+	async retrieveBinaryDataByIdentifier(identifier: string): Promise<Buffer> {
+		const { mode, id } = this.splitBinaryModeFileId(identifier);
+		if (this.managers[mode]) {
+			return this.managers[mode].retrieveBinaryDataByIdentifier(id);
+		}
+
+		throw new Error('Storage mode used to store binary data not available');
+	}
+
+	async markDataForDeletionByExecutionId(executionId: string): Promise<void> {
+		if (this.managers[this.binaryDataMode]) {
+			return this.managers[this.binaryDataMode].markDataForDeletionByExecutionId(executionId);
+		}
+
+		return Promise.resolve();
+	}
+
+	async persistBinaryDataForExecutionId(executionId: string): Promise<void> {
+		if (this.managers[this.binaryDataMode]) {
+			return this.managers[this.binaryDataMode].persistBinaryDataForExecutionId(executionId);
+		}
+
+		return Promise.resolve();
+	}
+
+	async deleteBinaryDataByExecutionId(executionId: string): Promise<void> {
+		if (this.managers[this.binaryDataMode]) {
+			return this.managers[this.binaryDataMode].deleteBinaryDataByExecutionId(executionId);
+		}
+
+		return Promise.resolve();
+	}
+
+	async duplicateBinaryData(
+		inputData: Array<INodeExecutionData[] | null> | unknown,
+		executionId: string,
+	): Promise<INodeExecutionData[][]> {
+		if (inputData && this.managers[this.binaryDataMode]) {
+			const returnInputData = (inputData as INodeExecutionData[][]).map(
+				async (executionDataArray) => {
+					if (executionDataArray) {
+						return Promise.all(
+							executionDataArray.map((executionData) => {
+								if (executionData.binary) {
+									return this.duplicateBinaryDataInExecData(executionData, executionId);
+								}
+
+								return executionData;
+							}),
+						);
+					}
+
+					return executionDataArray;
+				},
+			);
+
+			return Promise.all(returnInputData);
+		}
+
+		return Promise.resolve(inputData as INodeExecutionData[][]);
+	}
+
+	private generateBinaryId(filename: string) {
+		return `${this.binaryDataMode}:${filename}`;
+	}
+
+	private splitBinaryModeFileId(fileId: string): { mode: string; id: string } {
+		const [mode, id] = fileId.split(':');
+		return { mode, id };
+	}
+
+	private async duplicateBinaryDataInExecData(
+		executionData: INodeExecutionData,
+		executionId: string,
+	): Promise<INodeExecutionData> {
+		const binaryManager = this.managers[this.binaryDataMode];
+
+		if (executionData.binary) {
+			const binaryDataKeys = Object.keys(executionData.binary);
+			const bdPromises = binaryDataKeys.map(async (key: string) => {
+				if (!executionData.binary) {
+					return { key, newId: undefined };
+				}
+
+				const binaryDataId = executionData.binary[key].id;
+				if (!binaryDataId) {
+					return { key, newId: undefined };
+				}
+
+				return binaryManager
+					?.duplicateBinaryDataByIdentifier(
+						this.splitBinaryModeFileId(binaryDataId).id,
+						executionId,
+					)
+					.then((filename) => ({
+						newId: this.generateBinaryId(filename),
+						key,
+					}));
+			});
+
+			return Promise.all(bdPromises).then((b) => {
+				return b.reduce((acc, curr) => {
+					if (acc.binary && curr) {
+						acc.binary[curr.key].id = curr.newId;
+					}
+
+					return acc;
+				}, executionData);
+			});
+		}
+
+		return executionData;
+	}
+}

package/src/utils/crypto.ts

@@ -0,0 +1,5 @@
+import { randomInt } from 'crypto';
+
+export function secureRandomNumber(min: number, max: number): number {
+    return randomInt(min, max);
+}

package/tests/Credentials.test.ts

@@ -0,0 +1,88 @@
+import { Credentials } from '../src';
+
+describe('Credentials', () => {
+	describe('without nodeType set', () => {
+		test('should be able to set and read key data without initial data set', () => {
+			const credentials = new Credentials({ id: null, name: 'testName' }, 'testType', []);
+
+			const key = 'key1';
+			const password = '';
+			// const nodeType = 'base.noOp';
+			const newData = 1234;
+
+			credentials.setDataKey(key, newData, password);
+
+			expect(credentials.getDataKey(key, password)).toEqual(newData);
+		});
+
+		test('should be able to set and read key data with initial data set', () => {
+			const key = 'key2';
+			const password = '';
+
+			// Saved under "key1"
+			const initialData = 4321;
+			const initialDataEncoded = 'U2FsdGVkX1+0baznXt+Ag/ub8A2kHLyoLxn/rR9h4XQ=';
+
+			const credentials = new Credentials(
+				{ id: null, name: 'testName' },
+				'testType',
+				[],
+				initialDataEncoded,
+			);
+
+			const newData = 1234;
+
+			// Set and read new data
+			credentials.setDataKey(key, newData, password);
+			expect(credentials.getDataKey(key, password)).toEqual(newData);
+
+			// Read the data which got provided encrypted on init
+			expect(credentials.getDataKey('key1', password)).toEqual(initialData);
+		});
+	});
+
+	describe('with nodeType set', () => {
+		test('should be able to set and read key data without initial data set', () => {
+			const nodeAccess = [
+				{
+					nodeType: 'base.noOp',
+					user: 'userName',
+					date: new Date(),
+				},
+			];
+
+			const credentials = new Credentials({ id: null, name: 'testName' }, 'testType', nodeAccess);
+
+			const key = 'key1';
+			const password = '';
+			const nodeType = 'base.noOp';
+			const newData = 1234;
+
+			credentials.setDataKey(key, newData, password);
+
+			// Should be able to read with nodeType which has access
+			expect(credentials.getDataKey(key, password, nodeType)).toEqual(newData);
+
+			// Should not be able to read with nodeType which does NOT have access
+			// expect(credentials.getDataKey(key, password, 'base.otherNode')).toThrowError(Error);
+			try {
+				credentials.getDataKey(key, password, 'base.otherNode');
+				expect(true).toBe(false);
+			} catch (e: any) {
+				expect(e.message).toBe(
+					'The node of type "base.otherNode" does not have access to credentials "testName" of type "testType".',
+				);
+			}
+
+			// Get the data which will be saved in database
+			const dbData = credentials.getDataToSave();
+			expect(dbData.name).toEqual('testName');
+			expect(dbData.type).toEqual('testType');
+			expect(dbData.nodesAccess).toEqual(nodeAccess);
+			// Compare only the first 6 characters as the rest seems to change with each execution
+			expect(dbData.data!.slice(0, 6)).toEqual(
+				'U2FsdGVkX1+wpQWkj+YTzaPSNTFATjnlmFKIsUTZdhk='.slice(0, 6),
+			);
+		});
+	});
+});