@fsai-flow/core 0.0.1

package/src/lib/NodesLoader/package-directory-loader.ts

@@ -0,0 +1,107 @@
+import { Icon, jsonParse } from '@fsai-flow/workflow';
+import { readFileSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+
+import { DirectoryLoader } from './directory-loader';
+import type { n8n } from './types';
+
+/**
+ * Loader for source files of nodes and credentials located in a package dir,
+ * e.g. /nodes-base or community packages.
+ */
+export class PackageDirectoryLoader extends DirectoryLoader {
+	packageJson: n8n.PackageJson;
+
+	packageName: string;
+
+	constructor(directory: string, excludeNodes: string[] = [], includeNodes: string[] = []) {
+		super(directory, excludeNodes, includeNodes);
+
+		this.packageJson = this.readJSONSync('package.json');
+		this.packageName = this.packageJson.name;
+		this.excludeNodes = this.extractNodeTypes(excludeNodes);
+		this.includeNodes = this.extractNodeTypes(includeNodes);
+	}
+
+	private extractNodeTypes(fullNodeTypes: string[]) {
+		return fullNodeTypes
+			.map((fullNodeType) => fullNodeType.split('.'))
+			.filter(([packageName]) => packageName === this.packageName)
+			.map(([_, nodeType]) => nodeType);
+	}
+
+	override async loadAll() {
+		const { n8n } = this.packageJson;
+		if (!n8n) return;
+
+		const { nodes, credentials } = n8n;
+
+		if (Array.isArray(nodes)) {
+			for (const nodePath of nodes) {
+				this.loadNodeFromFile(nodePath);
+			}
+		}
+
+		if (Array.isArray(credentials)) {
+			for (const credentialPath of credentials) {
+				this.loadCredentialFromFile(credentialPath);
+			}
+		}
+
+		this.inferSupportedNodes();
+
+		console.debug(`Loaded all credentials and nodes from ${this.packageName}`, {
+			credentials: credentials?.length ?? 0,
+			nodes: nodes?.length ?? 0,
+		});
+	}
+
+	private inferSupportedNodes() {
+		const knownCredentials = this.known.credentials;
+		for (const { type: credentialType } of Object.values(this.credentialTypes)) {
+			const supportedNodes = knownCredentials[credentialType.name].supportedNodes ?? [];
+			if (supportedNodes.length > 0 && credentialType.httpRequestNode) {
+				credentialType.httpRequestNode.hidden = true;
+			}
+
+			credentialType.supportedNodes = supportedNodes;
+
+			if (!credentialType.iconUrl && !credentialType.icon) {
+				for (const supportedNode of supportedNodes) {
+					const nodeDescription = this.nodeTypes[supportedNode]?.type.description;
+
+					if (!nodeDescription) continue;
+					if (nodeDescription.icon) {
+						credentialType.icon = nodeDescription.icon as Icon;
+						credentialType.iconColor = nodeDescription.iconColor;
+						break;
+					}
+					if (nodeDescription.iconUrl) {
+						credentialType.iconUrl = nodeDescription.iconUrl;
+						break;
+					}
+				}
+			}
+		}
+	}
+
+	private parseJSON<T>(fileString: string, filePath: string): T {
+		try {
+			return jsonParse<T>(fileString);
+		} catch (error) {
+			throw new Error(`Failed to parse JSON, ${filePath}`);
+		}
+	}
+
+	protected readJSONSync<T>(file: string): T {
+		const filePath = this.resolvePath(file);
+		const fileString = readFileSync(filePath, 'utf8');
+		return this.parseJSON<T>(fileString, filePath);
+	}
+
+	protected async readJSON<T>(file: string): Promise<T> {
+		const filePath = this.resolvePath(file);
+		const fileString = await readFile(filePath, 'utf8');
+		return this.parseJSON<T>(fileString, filePath);
+	}
+}

package/src/lib/NodesLoader/types.ts

@@ -0,0 +1,14 @@
+export namespace n8n {
+	export interface PackageJson {
+		name: string;
+		version: string;
+		n8n?: {
+			credentials?: string[];
+			nodes?: string[];
+		};
+		author?: {
+			name?: string;
+			email?: string;
+		};
+	}
+}

package/src/lib/UserSettings.ts

@@ -0,0 +1,292 @@
+/* eslint-disable no-param-reassign */
+/* eslint-disable @typescript-eslint/no-use-before-define */
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+import * as fs from 'fs';
+import * as path from 'path';
+import { createHash, randomBytes } from 'crypto';
+// eslint-disable-next-line import/no-cycle
+import {
+	ENCRYPTION_KEY_ENV_OVERWRITE,
+	EXTENSIONS_SUBDIRECTORY,
+	IUserSettings,
+	USER_FOLDER_ENV_OVERWRITE,
+	USER_SETTINGS_FILE_NAME,
+	USER_SETTINGS_SUBFOLDER,
+} from '../../src';
+
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const { promisify } = require('util');
+
+const fsAccess = promisify(fs.access);
+const fsReadFile = promisify(fs.readFile);
+const fsMkdir = promisify(fs.mkdir);
+const fsWriteFile = promisify(fs.writeFile);
+
+let settingsCache: IUserSettings | undefined;
+
+/**
+ * Creates the user settings if they do not exist yet
+ *
+ * @export
+ */
+export async function prepareUserSettings(): Promise<IUserSettings> {
+	const settingsPath = getUserSettingsPath();
+
+	let userSettings = await getUserSettings(settingsPath);
+	if (userSettings !== undefined) {
+		// Settings already exist, check if they contain the encryptionKey
+		if (userSettings.encryptionKey !== undefined) {
+			// Key already exists
+			if (userSettings.instanceId === undefined) {
+				userSettings.instanceId = await generateInstanceId(userSettings.encryptionKey);
+				settingsCache = userSettings;
+			}
+
+			return userSettings;
+		}
+	} else {
+		userSettings = {};
+	}
+
+	if (process.env[ENCRYPTION_KEY_ENV_OVERWRITE] !== undefined) {
+		// Use the encryption key which got set via environment
+		userSettings.encryptionKey = process.env[ENCRYPTION_KEY_ENV_OVERWRITE];
+	} else {
+		// Generate a new encryption key
+		userSettings.encryptionKey = randomBytes(24).toString('base64');
+	}
+
+	userSettings.instanceId = await generateInstanceId(userSettings.encryptionKey);
+
+	// eslint-disable-next-line no-console
+	console.log(`UserSettings were generated and saved to: ${settingsPath}`);
+
+	return writeUserSettings(userSettings, settingsPath);
+}
+
+/**
+ * Returns the encryption key which is used to encrypt
+ * the credentials.
+ *
+ * @export
+ * @returns
+ */
+
+export async function getEncryptionKey(): Promise<string | undefined> {
+	if (process.env[ENCRYPTION_KEY_ENV_OVERWRITE] !== undefined) {
+		return process.env[ENCRYPTION_KEY_ENV_OVERWRITE];
+	}
+
+	const userSettings = await getUserSettings();
+
+	if (userSettings === undefined) {
+		return undefined;
+	}
+
+	if (userSettings.encryptionKey === undefined) {
+		return undefined;
+	}
+
+	return userSettings.encryptionKey;
+}
+
+/**
+ * Returns the instance ID
+ *
+ * @export
+ * @returns
+ */
+export async function getInstanceId(): Promise<string> {
+	const userSettings = await getUserSettings();
+
+	if (userSettings === undefined) {
+		return '';
+	}
+
+	if (userSettings.instanceId === undefined) {
+		return '';
+	}
+
+	return userSettings.instanceId;
+}
+
+async function generateInstanceId(key?: string) {
+	const hash = key
+		? createHash('sha256')
+				.update(key.slice(Math.round(key.length / 2)))
+				.digest('hex')
+		: undefined;
+
+	return hash;
+}
+
+/**
+ * Adds/Overwrite the given settings in the currently
+ * saved user settings
+ *
+ * @export
+ * @param {IUserSettings} addSettings  The settings to add/overwrite
+ * @param {string} [settingsPath] Optional settings file path
+ * @returns {Promise<IUserSettings>}
+ */
+export async function addToUserSettings(
+	addSettings: IUserSettings,
+	settingsPath?: string,
+): Promise<IUserSettings> {
+	if (settingsPath === undefined) {
+		settingsPath = getUserSettingsPath();
+	}
+
+	let userSettings = await getUserSettings(settingsPath);
+
+	if (userSettings === undefined) {
+		userSettings = {};
+	}
+
+	// Add the settings
+	Object.assign(userSettings, addSettings);
+
+	return writeUserSettings(userSettings, settingsPath);
+}
+
+/**
+ * Writes a user settings file
+ *
+ * @export
+ * @param {IUserSettings} userSettings The settings to write
+ * @param {string} [settingsPath] Optional settings file path
+ * @returns {Promise<IUserSettings>}
+ */
+export async function writeUserSettings(
+	userSettings: IUserSettings,
+	settingsPath?: string,
+): Promise<IUserSettings> {
+	if (settingsPath === undefined) {
+		settingsPath = getUserSettingsPath();
+	}
+
+	if (userSettings === undefined) {
+		userSettings = {};
+	}
+
+	// Check if parent folder exists if not create it.
+	try {
+		await fsAccess(path.dirname(settingsPath));
+	} catch (error) {
+		// Parent folder does not exist so create
+		await fsMkdir(path.dirname(settingsPath));
+	}
+
+	const settingsToWrite = { ...userSettings };
+	if (settingsToWrite.instanceId !== undefined) {
+		delete settingsToWrite.instanceId;
+	}
+
+	await fsWriteFile(settingsPath, JSON.stringify(settingsToWrite, null, '\t'));
+	settingsCache = JSON.parse(JSON.stringify(userSettings));
+
+	return userSettings;
+}
+
+/**
+ * Returns the content of the user settings
+ *
+ * @export
+ * @returns {UserSettings}
+ */
+export async function getUserSettings(
+	settingsPath?: string,
+	ignoreCache?: boolean,
+): Promise<IUserSettings | undefined> {
+	if (settingsCache !== undefined && ignoreCache !== true) {
+		return settingsCache;
+	}
+
+	if (settingsPath === undefined) {
+		settingsPath = getUserSettingsPath();
+	}
+
+	try {
+		await fsAccess(settingsPath);
+	} catch (error) {
+		// The file does not exist
+		return undefined;
+	}
+
+	const settingsFile = await fsReadFile(settingsPath, 'utf8');
+
+	try {
+		settingsCache = JSON.parse(settingsFile);
+	} catch (error) {
+		throw new Error(
+			`Error parsing n8n-config file "${settingsPath}". It does not seem to be valid JSON.`,
+		);
+	}
+
+	return settingsCache as IUserSettings;
+}
+
+/**
+ * Returns the path to the user settings
+ *
+ * @export
+ * @returns {string}
+ */
+export function getUserSettingsPath(): string {
+	const n8nFolder = getUserN8nFolderPath();
+
+	return path.join(n8nFolder, USER_SETTINGS_FILE_NAME);
+}
+
+/**
+ * Retruns the path to the n8n folder in which all n8n
+ * related data gets saved
+ *
+ * @export
+ * @returns {string}
+ */
+export function getUserN8nFolderPath(): string {
+	let userFolder;
+	if (process.env[USER_FOLDER_ENV_OVERWRITE] !== undefined) {
+		userFolder = process.env[USER_FOLDER_ENV_OVERWRITE] as string;
+	} else {
+		userFolder = getUserHome();
+	}
+
+	return path.join(userFolder, USER_SETTINGS_SUBFOLDER);
+}
+
+/**
+ * Returns the path to the n8n user folder with the custom
+ * extensions like nodes and credentials
+ *
+ * @export
+ * @returns {string}
+ */
+export function getUserN8nFolderCustomExtensionPath(): string {
+	return path.join(getUserN8nFolderPath(), EXTENSIONS_SUBDIRECTORY);
+}
+
+/**
+ * Returns the home folder path of the user if
+ * none can be found it falls back to the current
+ * working directory
+ *
+ * @export
+ * @returns {string}
+ */
+export function getUserHome(): string {
+	let variableName = 'HOME';
+	if (process.platform === 'win32') {
+		variableName = 'USERPROFILE';
+	}
+
+	if (process.env[variableName] === undefined) {
+		// If for some reason the variable does not exist
+		// fall back to current folder
+		return process.cwd();
+	}
+
+	return process.env[variableName] as string;
+}