n8n-nodes-oracle11g 1.0.0

package/credentials/Oracle11gApi.credentials.js

@@ -0,0 +1,65 @@
+class Oracle11gApi {
+    constructor() {
+        this.name = 'oracle11gApi';
+        this.displayName = 'Oracle 11g API';
+        this.properties = [
+            {
+                displayName: 'Host',
+                name: 'host',
+                type: 'string',
+                default: '',
+                required: true,
+            },
+            {
+                displayName: 'Port',
+                name: 'port',
+                type: 'number',
+                default: 1521,
+                required: true,
+            },
+            {
+                displayName: 'Database',
+                name: 'database',
+                type: 'string',
+                default: '',
+                required: true,
+            },
+            {
+                displayName: 'Username',
+                name: 'username',
+                type: 'string',
+                default: '',
+                required: true,
+            },
+            {
+                displayName: 'Password',
+                name: 'password',
+                type: 'string',
+                typeOptions: {
+                    password: true,
+                },
+                default: '',
+                required: true,
+            },
+            {
+                displayName: 'Connection Type',
+                name: 'connectionType',
+                type: 'options',
+                options: [
+                    {
+                        name: 'Service Name',
+                        value: 'service',
+                    },
+                    {
+                        name: 'SID',
+                        value: 'sid',
+                    },
+                ],
+                default: 'service',
+                required: true,
+            },
+        ];
+    }
+}
+
+module.exports = { Oracle11gApi };

package/credentials/Oracle11gApi.credentials.ts

@@ -0,0 +1,67 @@
+import {
+	ICredentialType,
+	INodeProperties,
+} from 'n8n-workflow';
+
+export class Oracle11gApi implements ICredentialType {
+	name = 'oracle11gApi';
+	displayName = 'Oracle 11g Database';
+	documentationUrl = 'https://docs.oracle.com/cd/B28359_01/server.111/b28318/toc.htm';
+	properties: INodeProperties[] = [
+		{
+			displayName: 'Host',
+			name: 'host',
+			type: 'string',
+			default: 'localhost',
+			required: true,
+		},
+		{
+			displayName: 'Port',
+			name: 'port',
+			type: 'number',
+			default: 1521,
+			required: true,
+		},
+		{
+			displayName: 'Service Name / SID',
+			name: 'database',
+			type: 'string',
+			default: '',
+			placeholder: 'ORCL or XE',
+			required: true,
+		},
+		{
+			displayName: 'Username',
+			name: 'username',
+			type: 'string',
+			default: '',
+			required: true,
+		},
+		{
+			displayName: 'Password',
+			name: 'password',
+			type: 'string',
+			typeOptions: {
+				password: true,
+			},
+			default: '',
+			required: true,
+		},
+		{
+			displayName: 'Connection Type',
+			name: 'connectionType',
+			type: 'options',
+			options: [
+				{
+					name: 'Service Name',
+					value: 'serviceName',
+				},
+				{
+					name: 'SID',
+					value: 'sid',
+				},
+			],
+			default: 'serviceName',
+		},
+	];
+}

package/dist/credentials/Oracle11gApi.credentials.d.ts

@@ -0,0 +1,7 @@
+import { ICredentialType, INodeProperties } from 'n8n-workflow';
+export declare class Oracle11gApi implements ICredentialType {
+    name: string;
+    displayName: string;
+    documentationUrl: string;
+    properties: INodeProperties[];
+}

package/dist/credentials/Oracle11gApi.credentials.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Oracle11gApi = void 0;
+
+class Oracle11gApi {
+    constructor() {
+        this.name = 'oracle11gApi';
+        this.displayName = 'Oracle 11g Database';
+        this.documentationUrl = 'https://docs.oracle.com/cd/B28359_01/server.111/b28318/toc.htm';
+        this.properties = [
+            {
+                displayName: 'Host',
+                name: 'host',
+                type: 'string',
+                default: 'localhost',
+                required: true,
+            },
+            {
+                displayName: 'Port',
+                name: 'port',
+                type: 'number',
+                default: 1521,
+                required: true,
+            },
+            {
+                displayName: 'Service Name / SID',
+                name: 'database',
+                type: 'string',
+                default: '',
+                placeholder: 'ORCL or XE',
+                required: true,
+            },
+            {
+                displayName: 'Username',
+                name: 'username',
+                type: 'string',
+                default: '',
+                required: true,
+            },
+            {
+                displayName: 'Password',
+                name: 'password',
+                type: 'string',
+                typeOptions: {
+                    password: true,
+                },
+                default: '',
+                required: true,
+            },
+            {
+                displayName: 'Connection Type',
+                name: 'connectionType',
+                type: 'options',
+                options: [
+                    {
+                        name: 'Service Name',
+                        value: 'serviceName',
+                    },
+                    {
+                        name: 'SID',
+                        value: 'sid',
+                    },
+                ],
+                default: 'serviceName',
+            },
+        ];
+    }
+}
+exports.Oracle11gApi = Oracle11gApi;

package/dist/nodes/Oracle11g/Oracle11g.node.d.ts

@@ -0,0 +1,5 @@
+import { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription } from 'n8n-workflow';
+export declare class Oracle11g implements INodeType {
+    description: INodeTypeDescription;
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}

package/dist/nodes/Oracle11g/Oracle11g.node.js

@@ -0,0 +1,100 @@
+const { NodeOperationError } = require('n8n-workflow');
+const oracledb = require('oracledb');
+
+class Oracle11g {
+    constructor() {
+        this.description = {
+            displayName: 'Oracle 11g Database',
+            name: 'oracle11g',
+            icon: 'fa:database',
+            group: ['input'],
+            version: 1,
+            description: 'Execute SQL queries on Oracle 11g database',
+            defaults: {
+                name: 'Oracle 11g Database',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            credentials: [
+                {
+                    name: 'oracle11gApi',
+                    required: true,
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Query',
+                    name: 'query',
+                    type: 'string',
+                    typeOptions: {
+                        rows: 5,
+                    },
+                    default: 'SELECT SYSDATE FROM DUAL',
+                    placeholder: 'SELECT * FROM your_table',
+                    description: 'SQL query to execute',
+                },
+            ],
+        };
+    }
+    
+    async execute(executeFunctions) {
+        const items = executeFunctions.getInputData();
+        const returnData = [];
+        
+        // Initialize Oracle client
+        try {
+            oracledb.initOracleClient({ libDir: '/oracle/instantclient_21_9' });
+        } catch (err) {
+            // Already initialized
+        }
+        
+        for (let i = 0; i < items.length; i++) {
+            try {
+                const credentials = await executeFunctions.getCredentials('oracle11gApi');
+                const query = executeFunctions.getNodeParameter('query', i);
+                
+                const connectString = `${credentials.host}:${credentials.port}/${credentials.database}`;
+                
+                const connection = await oracledb.getConnection({
+                    user: credentials.username,
+                    password: credentials.password,
+                    connectString,
+                });
+                
+                const result = await connection.execute(query, [], {
+                    outFormat: oracledb.OUT_FORMAT_OBJECT,
+                });
+                
+                if (result.rows && Array.isArray(result.rows)) {
+                    for (const row of result.rows) {
+                        returnData.push({
+                            json: row,
+                            pairedItem: { item: i },
+                        });
+                    }
+                } else {
+                    returnData.push({
+                        json: { success: true, rowsAffected: result.rowsAffected || 0 },
+                        pairedItem: { item: i },
+                    });
+                }
+                
+                await connection.close();
+                
+            } catch (error) {
+                if (executeFunctions.continueOnFail()) {
+                    returnData.push({
+                        json: { error: error.message },
+                        pairedItem: { item: i },
+                    });
+                    continue;
+                }
+                throw new NodeOperationError(executeFunctions.getNode(), error, { itemIndex: i });
+            }
+        }
+        
+        return [returnData];
+    }
+}
+
+module.exports = { Oracle11g };

package/nodes/Oracle11g/Oracle11g.node.js

@@ -0,0 +1,78 @@
+const { NodeOperationError } = require('n8n-workflow');
+
+class Oracle11g {
+    constructor() {
+        this.description = {
+            displayName: 'Oracle 11g',
+            name: 'oracle11g',
+            icon: 'fa:database',
+            group: ['input'],
+            version: 1,
+            description: 'Execute SQL queries on Oracle 11g database',
+            defaults: {
+                name: 'Oracle 11g',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            credentials: [
+                {
+                    name: 'oracle11gApi',
+                    required: true,
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'SQL Query',
+                    name: 'query',
+                    type: 'string',
+                    typeOptions: {
+                        rows: 5,
+                    },
+                    default: 'SELECT SYSDATE FROM dual',
+                    required: true,
+                    description: 'SQL query to execute',
+                },
+            ],
+        };
+    }
+
+    async execute(executeFunctions) {
+        const items = executeFunctions.getInputData();
+        const returnData = [];
+        const oracledb = require('oracledb');
+
+        for (let i = 0; i < items.length; i++) {
+            try {
+                const credentials = await executeFunctions.getCredentials('oracle11gApi');
+                const query = executeFunctions.getNodeParameter('query', i);
+
+                const connectionString = credentials.connectionType === 'service' 
+                    ? credentials.host + ':' + credentials.port + '/' + credentials.database
+                    : credentials.host + ':' + credentials.port + ':' + credentials.database;
+
+                const connection = await oracledb.getConnection({
+                    user: credentials.username,
+                    password: credentials.password,
+                    connectString: connectionString,
+                });
+
+                const result = await connection.execute(query);
+                await connection.close();
+
+                returnData.push({
+                    json: {
+                        query,
+                        result: result.rows,
+                        columns: result.metaData ? result.metaData.map(col => col.name) : [],
+                    },
+                });
+            } catch (error) {
+                throw new NodeOperationError(executeFunctions.getNode(), error, { itemIndex: i });
+            }
+        }
+
+        return [returnData];
+    }
+}
+
+module.exports = { Oracle11g };

package/nodes/Oracle11g/Oracle11g.node.ts

@@ -0,0 +1,295 @@
+import {
+	IExecuteFunctions,
+	INodeExecutionData,
+	INodeType,
+	INodeTypeDescription,
+	NodeOperationError,
+} from 'n8n-workflow';
+
+import * as oracledb from 'oracledb';
+
+export class Oracle11g implements INodeType {
+	description: INodeTypeDescription = {
+		displayName: 'Oracle 11g Database',
+		name: 'oracle11g',
+		icon: 'file:oracle.svg',
+		group: ['input', 'output'],
+		version: 1,
+		description: 'Execute SQL queries on Oracle 11g database',
+		defaults: {
+			name: 'Oracle 11g',
+		},
+		inputs: ['main'],
+		outputs: ['main'],
+		credentials: [
+			{
+				name: 'oracle11gApi',
+				required: true,
+			},
+		],
+		properties: [
+			{
+				displayName: 'Operation',
+				name: 'operation',
+				type: 'options',
+				noDataExpression: true,
+				options: [
+					{
+						name: 'Execute Query',
+						value: 'executeQuery',
+						description: 'Execute a SQL query and return results',
+						action: 'Execute a SQL query',
+					},
+					{
+						name: 'Insert',
+						value: 'insert',
+						description: 'Insert data into table',
+						action: 'Insert data into table',
+					},
+					{
+						name: 'Update',
+						value: 'update',
+						description: 'Update data in table',
+						action: 'Update data in table',
+					},
+				],
+				default: 'executeQuery',
+			},
+			{
+				displayName: 'Query',
+				name: 'query',
+				type: 'string',
+				displayOptions: {
+					show: {
+						operation: ['executeQuery'],
+					},
+				},
+				typeOptions: {
+					editor: 'sqlEditor',
+					rows: 5,
+				},
+				default: 'SELECT SYSDATE FROM DUAL',
+				placeholder: 'SELECT * FROM your_table WHERE condition = :value',
+				description: 'SQL query to execute. Use :paramName for parameters.',
+			},
+			{
+				displayName: 'Table',
+				name: 'table',
+				type: 'string',
+				displayOptions: {
+					show: {
+						operation: ['insert', 'update'],
+					},
+				},
+				default: '',
+				placeholder: 'TABLE_NAME',
+				description: 'Name of the table',
+			},
+			{
+				displayName: 'Columns',
+				name: 'columns',
+				type: 'string',
+				displayOptions: {
+					show: {
+						operation: ['insert'],
+					},
+				},
+				default: '',
+				placeholder: 'column1, column2, column3',
+				description: 'Comma-separated list of column names',
+			},
+			{
+				displayName: 'Values',
+				name: 'values',
+				type: 'string',
+				displayOptions: {
+					show: {
+						operation: ['insert'],
+					},
+				},
+				default: '',
+				placeholder: ':value1, :value2, :value3',
+				description: 'Comma-separated list of values (use :paramName for parameters)',
+			},
+			{
+				displayName: 'Set Clause',
+				name: 'setClause',
+				type: 'string',
+				displayOptions: {
+					show: {
+						operation: ['update'],
+					},
+				},
+				default: '',
+				placeholder: 'column1 = :value1, column2 = :value2',
+				description: 'SET clause for UPDATE (use :paramName for parameters)',
+			},
+			{
+				displayName: 'Where Clause',
+				name: 'whereClause',
+				type: 'string',
+				displayOptions: {
+					show: {
+						operation: ['update'],
+					},
+				},
+				default: '',
+				placeholder: 'id = :id',
+				description: 'WHERE clause for UPDATE (use :paramName for parameters)',
+			},
+			{
+				displayName: 'Parameters',
+				name: 'parameters',
+				type: 'fixedCollection',
+				typeOptions: {
+					multipleValues: true,
+				},
+				default: {},
+				placeholder: 'Add Parameter',
+				description: 'Parameters for the SQL query',
+				options: [
+					{
+						name: 'parameter',
+						displayName: 'Parameter',
+						values: [
+							{
+								displayName: 'Name',
+								name: 'name',
+								type: 'string',
+								default: '',
+								placeholder: 'paramName',
+								description: 'Parameter name (without :)',
+							},
+							{
+								displayName: 'Value',
+								name: 'value',
+								type: 'string',
+								default: '',
+								description: 'Parameter value',
+							},
+						],
+					},
+				],
+			},
+		],
+	};
+
+	async execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
+		const items = this.getInputData();
+		const returnData: INodeExecutionData[] = [];
+
+		// Initialize Oracle client in thick mode
+		try {
+			oracledb.initOracleClient({ libDir: '/oracle/instantclient_21_9' });
+		} catch (err) {
+			// Already initialized
+		}
+
+		for (let i = 0; i < items.length; i++) {
+			try {
+				const credentials = await this.getCredentials('oracle11gApi');
+				const operation = this.getNodeParameter('operation', i) as string;
+
+				// Build connection string
+				const connectionType = credentials.connectionType as string;
+				let connectString: string;
+				
+				if (connectionType === 'sid') {
+					connectString = `${credentials.host}:${credentials.port}:${credentials.database}`;
+				} else {
+					connectString = `${credentials.host}:${credentials.port}/${credentials.database}`;
+				}
+
+				const connectionConfig: oracledb.ConnectionAttributes = {
+					user: credentials.username as string,
+					password: credentials.password as string,
+					connectString,
+				};
+
+				let connection: oracledb.Connection;
+
+				try {
+					connection = await oracledb.getConnection(connectionConfig);
+					
+					let query = '';
+					let bindParams: any = {};
+
+					// Build parameters
+					const parameters = this.getNodeParameter('parameters', i) as any;
+					if (parameters.parameter) {
+						for (const param of parameters.parameter) {
+							bindParams[param.name] = param.value;
+						}
+					}
+
+					// Build query based on operation
+					if (operation === 'executeQuery') {
+						query = this.getNodeParameter('query', i) as string;
+					} else if (operation === 'insert') {
+						const table = this.getNodeParameter('table', i) as string;
+						const columns = this.getNodeParameter('columns', i) as string;
+						const values = this.getNodeParameter('values', i) as string;
+						query = `INSERT INTO ${table} (${columns}) VALUES (${values})`;
+					} else if (operation === 'update') {
+						const table = this.getNodeParameter('table', i) as string;
+						const setClause = this.getNodeParameter('setClause', i) as string;
+						const whereClause = this.getNodeParameter('whereClause', i) as string;
+						query = `UPDATE ${table} SET ${setClause}`;
+						if (whereClause) {
+							query += ` WHERE ${whereClause}`;
+						}
+					}
+
+					const result = await connection.execute(query, bindParams, {
+						outFormat: oracledb.OUT_FORMAT_OBJECT,
+						fetchArraySize: 100,
+					});
+
+					if (operation === 'executeQuery' && result.rows && Array.isArray(result.rows)) {
+						for (const row of result.rows) {
+							returnData.push({
+								json: row as any,
+								pairedItem: { item: i },
+							});
+						}
+					} else {
+						// For INSERT/UPDATE operations
+						returnData.push({
+							json: {
+								operation,
+								rowsAffected: result.rowsAffected || 0,
+								success: true,
+							},
+							pairedItem: { item: i },
+						});
+					}
+
+					await connection.close();
+				} catch (error) {
+					if (connection!) {
+						await connection.close();
+					}
+					throw error;
+				}
+
+			} catch (error) {
+				if (this.continueOnFail()) {
+					returnData.push({
+						json: {
+							error: error.message,
+						},
+						pairedItem: {
+							item: i,
+						},
+					});
+					continue;
+				}
+				throw new NodeOperationError(this.getNode(), error as Error, {
+					itemIndex: i,
+				});
+			}
+		}
+
+		return [returnData];
+	}
+}

package/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "n8n-nodes-oracle11g",
+  "version": "1.0.0",
+  "description": "Oracle 11g node for n8n",
+  "main": "index.js",
+  "n8n": {
+    "nodes": ["nodes/Oracle11g/Oracle11g.node.js"],
+    "credentials": ["credentials/Oracle11gApi.credentials.js"]
+  },
+  "dependencies": {
+    "oracledb": "^6.0.0"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,32 @@
+{
+  "compilerOptions": {
+    "target": "es2019",
+    "module": "commonjs",
+    "lib": ["es2019"],
+    "declaration": true,
+    "outDir": "./dist",
+    "rootDir": "./",
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "moduleResolution": "node",
+    "allowSyntheticDefaultImports": true,
+    "esModuleInterop": true,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true
+  },
+  "include": [
+    "credentials/**/*",
+    "nodes/**/*"
+  ],
+  "exclude": [
+    "dist",
+    "node_modules",
+    "**/*.test.ts"
+  ]
+}