feat(Postgres Node): Overhaul node

packages/nodes-base/nodes/Postgres/v2/methods/credentialTest.ts

@@ -0,0 +1,68 @@
+import type {
+	ICredentialsDecrypted,
+	ICredentialTestFunctions,
+	IDataObject,
+	INodeCredentialTestResult,
+} from 'n8n-workflow';
+
+import { Connections } from '../transport';
+
+import { Client } from 'ssh2';
+import type { ConnectionsData, PgpClient } from '../helpers/interfaces';
+
+export async function postgresConnectionTest(
+	this: ICredentialTestFunctions,
+	credential: ICredentialsDecrypted,
+): Promise<INodeCredentialTestResult> {
+	const credentials = credential.data as IDataObject;
+
+	let sshClientCreated: Client | undefined = new Client();
+	let pgpClientCreated: PgpClient | undefined;
+
+	try {
+		const { db, pgp, sshClient } = (await Connections.getInstance(
+			credentials,
+			{},
+			true,
+			sshClientCreated,
+		)) as ConnectionsData;
+
+		sshClientCreated = sshClient;
+		pgpClientCreated = pgp;
+
+		await db.connect();
+	} catch (error) {
+		let message = error.message as string;
+
+		if (error.message.includes('ECONNREFUSED')) {
+			message = 'Connection refused';
+		}
+
+		if (error.message.includes('ENOTFOUND')) {
+			message = 'Host not found, please check your host name';
+		}
+
+		if (error.message.includes('ETIMEDOUT')) {
+			message = 'Connection timed out';
+		}
+
+		return {
+			status: 'Error',
+			message,
+		};
+	} finally {
+		if (sshClientCreated) {
+			sshClientCreated.end();
+		}
+		if (pgpClientCreated) {
+			pgpClientCreated.end();
+		}
+
+		//set the connection instance to null so that it can be recreated
+		await Connections.getInstance({}, {}, false, undefined, true);
+	}
+	return {
+		status: 'OK',
+		message: 'Connection successful!',
+	};
+}

packages/nodes-base/nodes/Postgres/v2/methods/index.ts

@@ -0,0 +1,3 @@
+export * as credentialTest from './credentialTest';
+export * as listSearch from './listSearch';
+export * as loadOptions from './loadOptions';

packages/nodes-base/nodes/Postgres/v2/methods/listSearch.ts

@@ -0,0 +1,47 @@
+import type { ILoadOptionsFunctions, INodeListSearchResult } from 'n8n-workflow';
+import type { ConnectionsData } from '../helpers/interfaces';
+import { Connections } from '../transport';
+
+export async function schemaSearch(this: ILoadOptionsFunctions): Promise<INodeListSearchResult> {
+	const credentials = await this.getCredentials('postgres');
+
+	const { db } = (await Connections.getInstance(credentials)) as ConnectionsData;
+
+	try {
+		const response = await db.any('SELECT schema_name FROM information_schema.schemata');
+
+		return {
+			results: response.map((schema) => ({
+				name: schema.schema_name as string,
+				value: schema.schema_name as string,
+			})),
+		};
+	} catch (error) {
+		throw error;
+	}
+}
+export async function tableSearch(this: ILoadOptionsFunctions): Promise<INodeListSearchResult> {
+	const credentials = await this.getCredentials('postgres');
+
+	const { db } = (await Connections.getInstance(credentials)) as ConnectionsData;
+
+	const schema = this.getNodeParameter('schema', 0, {
+		extractValue: true,
+	}) as string;
+
+	try {
+		const response = await db.any(
+			'SELECT table_name FROM information_schema.tables WHERE table_schema=$1',
+			[schema],
+		);
+
+		return {
+			results: response.map((table) => ({
+				name: table.table_name as string,
+				value: table.table_name as string,
+			})),
+		};
+	} catch (error) {
+		throw error;
+	}
+}

packages/nodes-base/nodes/Postgres/v2/methods/loadOptions.ts

@@ -0,0 +1,46 @@
+import type { ILoadOptionsFunctions, INodePropertyOptions } from 'n8n-workflow';
+import type { ConnectionsData } from '../helpers/interfaces';
+import { getTableSchema } from '../helpers/utils';
+import { Connections } from '../transport';
+
+export async function getColumns(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]> {
+	const credentials = await this.getCredentials('postgres');
+
+	const { db } = (await Connections.getInstance(credentials)) as ConnectionsData;
+
+	const schema = this.getNodeParameter('schema', 0, {
+		extractValue: true,
+	}) as string;
+
+	const table = this.getNodeParameter('table', 0, {
+		extractValue: true,
+	}) as string;
+
+	try {
+		const columns = await getTableSchema(db, schema, table);
+
+		return columns.map((column) => ({
+			name: column.column_name,
+			value: column.column_name,
+			description: `Type: ${column.data_type.toUpperCase()}, Nullable: ${column.is_nullable}`,
+		}));
+	} catch (error) {
+		throw error;
+	}
+}
+
+export async function getColumnsMultiOptions(
+	this: ILoadOptionsFunctions,
+): Promise<INodePropertyOptions[]> {
+	const returnData = await getColumns.call(this);
+	const returnAll = { name: '*', value: '*', description: 'All columns' };
+	return [returnAll, ...returnData];
+}
+
+export async function getColumnsWithoutColumnToMatchOn(
+	this: ILoadOptionsFunctions,
+): Promise<INodePropertyOptions[]> {
+	const columnToMatchOn = this.getNodeParameter('columnToMatchOn') as string;
+	const returnData = await getColumns.call(this);
+	return returnData.filter((column) => column.value !== columnToMatchOn);
+}