removed incomplete features from main

2026-02-11 19:03:40 -05:00
7 changed files with 12 additions and 298 deletions
--- a/package-lock.json
+++ b/package-lock.json
@@ -5,7 +5,7 @@
  "packages": {
    "": {
      "dependencies": {
-        "axios": "^1.13.5",
+        "axios": "^1.11.0",
        "cors": "^2.8.5",
        "dotenv": "^17.2.1",
        "express": "^5.1.0",
@@ -388,13 +388,13 @@
      }
    },
    "node_modules/axios": {
-      "version": "1.13.5",
-      "resolved": "https://registry.npmjs.org/axios/-/axios-1.13.5.tgz",
-      "integrity": "sha512-cz4ur7Vb0xS4/KUN0tPWe44eqxrIu31me+fbang3ijiNscE129POzipJJA6zniq2C/Z6sJCjMimjS8Lc/GAs8Q==",
+      "version": "1.11.0",
+      "resolved": "https://registry.npmjs.org/axios/-/axios-1.11.0.tgz",
+      "integrity": "sha512-1Lx3WLFQWm3ooKDYZD1eXmoGO9fxYQjrycfHFC8P0sCfQVXyROp0p9PFWBehewBOdCwHc+f/b8I0fMto5eSfwA==",
      "license": "MIT",
      "dependencies": {
-        "follow-redirects": "^1.15.11",
-        "form-data": "^4.0.5",
+        "follow-redirects": "^1.15.6",
+        "form-data": "^4.0.4",
        "proxy-from-env": "^1.1.0"
      }
    },
@@ -919,9 +919,9 @@
      }
    },
    "node_modules/form-data": {
-      "version": "4.0.5",
-      "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.5.tgz",
-      "integrity": "sha512-8RipRLol37bNs2bhoV67fiTEvdTrbMUYcFTiy3+wuuOnUog2QBHCZWXDRijWQfAkhBj2Uf5UnVaiWwA5vdd82w==",
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.4.tgz",
+      "integrity": "sha512-KrGhL9Q4zjj0kiUt5OO4Mr/A/jlI2jDYs5eHBpYHPcBEVSiipAvn2Ko2HnPe20rmcuuvMHNdZFp+4IlGTMF0Ow==",
      "license": "MIT",
      "dependencies": {
        "asynckit": "^0.4.0",
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
  "dependencies": {
-    "axios": "^1.13.5",
+    "axios": "^1.11.0",
    "cors": "^2.8.5",
    "dotenv": "^17.2.1",
    "express": "^5.1.0",
--- a/services/dbconnector/connectionManager.js
+++ b/services/dbconnector/connectionManager.js
@@ -2,9 +2,7 @@

 require('dotenv').config();
 const sql = require('mssql');
-const oracledb = require('oracledb');
 const mysql = require('mysql2/promise');
-const { Client } = require('pg');

 /**
 * Gets a connection based on the configured database type.
@@ -18,14 +16,8 @@ async function getConnection() {
    switch (dbType) {
        case 'MSSQL':
            return await sql.connect(config);
-        case 'ORACLE':
-            return await oracledb.getConnection(config);
        case 'MARIADB':
            return await mysql.createConnection(config);
-        case 'POSTGRES':
-            const client = new Client(config);
-            await client.connect();
-            return client;
        default:
            throw new Error('Unsupported database type');
    }
@@ -50,12 +42,6 @@ function getDBConfig(dbType) {
                    trustServerCertificate: true
                }
            };
-        case 'ORACLE':
-            return {
-                user: process.env.DB_USER,
-                password: process.env.DB_PASSWORD,
-                connectString: process.env.ORACLE_CONNECTION_STRING
-            };
        case 'MARIADB':
            return {
                host: process.env.DB_SERVER,
@@ -65,14 +51,6 @@ function getDBConfig(dbType) {
                database: process.env.DB_DATABASE,
                namedPlaceholders: true
            };
-        case 'POSTGRES':
-            return {
-                host: process.env.DB_SERVER,
-                port: parseInt(process.env.DB_PORT, 10) || 5432,
-                user: process.env.DB_USER,
-                password: process.env.DB_PASSWORD,
-                database: process.env.DB_DATABASE
-            };
        default:
            throw new Error('Unsupported database type');
    }
--- a/services/dbconnector/paramLibrary.js
+++ b/services/dbconnector/paramLibrary.js
@@ -28,15 +28,11 @@ async function formatQueryParams(params) {
        case 'MSSQL':
            formattedParams = formatMSSQLParams(params, paramsConfig.mssql);
            break;
-        case 'ORACLE':
-            formattedParams = formatOracleParams(params, paramsConfig.oracle);
-            break;
+
        case 'MARIADB':
            formattedParams = formatMariaDBParams(params, paramsConfig.mariaDB);
            break;
-        case 'POSTGRES':
-            formattedParams = formatPostgresParams(params, paramsConfig.postgres);
-            break;
+
        default:
            throw new Error('Unsupported database type');
    }
@@ -91,51 +87,6 @@ function formatMSSQLParams(params, config) {
    return formattedParams;
 }

-/**
- * Formats query parameters for Oracle.
- *
- * @param {Object} params - An object containing the parameters to format.
- * @param {Object} config - Database-specific configuration from JSON.
- * @returns {Object} Formatted parameters.
- */
-function formatOracleParams(params, config) {
-    const formattedParams = {};
-    for (const key in params) {
-        if (!config[key]) {
-            console.warn(`Parameter '${key}' not defined in the configuration.`);
-            continue;
-        }
-
-        const paramConfig = config[key];
-        let type;
-
-        switch (paramConfig.type.toLowerCase()) {
-            case 'string':
-                type = oracledb.STRING;
-                break;
-            case 'varchar2':
-                if (!paramConfig.maxLength) {
-                    throw new Error(`Parameter '${key}' is missing maxLength in configuration.`);
-                }
-                type = oracledb.VARCHAR2(paramConfig.maxLength);
-                break;
-            case 'clob':
-                type = oracledb.CLOB;
-                break;
-            case 'number':
-                type = oracledb.NUMBER;
-                break;
-            case 'boolean':
-                type = oracledb.BOOLEAN;
-                break;
-            default:
-                throw new Error(`Unsupported parameter type: ${paramConfig.type} for parameter '${key}'`);
-        }
-
-        formattedParams[key] = { type, value: params[key] };
-    }
-    return formattedParams;
-}

 /**
 * Formats query parameters for MariaDB.
@@ -186,51 +137,5 @@ function formatMariaDBParams(params, config) {
    return formattedParams;
 }

-/**
- * Formats query parameters for PostgreSQL.
- *
- * @param {Object} params - An object containing the parameters to format.
- * @param {Object} config - Database-specific configuration from JSON.
- * @returns {Object} Formatted parameters.
- */
-function formatPostgresParams(params, config) {
-    const formattedParams = {};
-    for (const key in params) {
-        if (!config[key]) {
-            console.warn(`Parameter '${key}' not defined in the configuration.`);
-            continue;
-        }
-
-        const paramConfig = config[key];
-        let type;
-
-        switch (paramConfig.type.toLowerCase()) {
-            case 'uuid':
-                type = 'uuid';
-                break;
-            case 'varchar':
-                if (!paramConfig.length) {
-                    throw new Error(`Parameter '${key}' is missing length in configuration.`);
-                }
-                type = { type: 'VARCHAR', length: paramConfig.length };
-                break;
-            case 'text':
-                type = 'text';
-                break;
-            case 'int':
-                type = 'int';
-                break;
-            case 'boolean':
-                type = 'boolean';
-                break;
-            default:
-                throw new Error(`Unsupported parameter type: ${paramConfig.type} for parameter '${key}'`);
-        }
-
-        formattedParams[key] = { type, value: params[key] };
-    }
-    return formattedParams;
-}
-
 module.exports = { formatQueryParams };

--- a/services/dbconnector/paramsConfig.json
+++ b/services/dbconnector/paramsConfig.json
@@ -24,28 +24,6 @@
        "Quantity": { "type": "int" },
        "RequestPayload": { "type": "text" }
    },
-    "oracle": {
-        "ID": { "type": "string" },
-        "Name": { "type": "varchar2", "maxLength": 255 },
-        "Description": { "type": "varchar2", "maxLength": 255 },
-        "Text": { "type": "varchar2", "maxLength": 255 },
-        "Building": { "type": "varchar2", "maxLength": 255 },
-        "Owner": { "type": "varchar2", "maxLength": 255 },
-        "Role": { "type": "varchar2", "maxLength": 255 },
-        "Location": { "type": "varchar2", "maxLength": 255 },
-        "Route": { "type": "varchar2", "maxLength": 255 },
-        "Email": { "type": "varchar2", "maxLength": 255 },
-        "DisplayName": { "type": "varchar2", "maxLength": 255 },
-        "Team": { "type": "varchar2", "maxLength": 255 },
-        "Username": { "type": "varchar2", "maxLength": 50 },
-        "AuthenticatedUsername": { "type": "varchar2", "maxLength": 50 },
-        "UITheme": { "type": "varchar2", "maxLength": 50 },
-        "Bio": { "type": "clob" },
-        "PasswordHash": { "type": "clob" },
-        "Image": { "type": "clob" },
-        "AvatarURL": { "type": "clob" },
-        "SQL_USER": { "type": "boolean" }
-    },
    "mariaDB": {
        "ID": { "type": "uuid" },
        "Name": { "type": "string" },
@@ -67,27 +45,5 @@
        "Image": { "type": "text" },
        "AvatarURL": { "type": "text" },
        "SQL_USER": { "type": "boolean" }
-    },
-    "postgres": {
-        "ID": { "type": "uuid" },
-        "Name": { "type": "varchar", "length": 255 },
-        "Description": { "type": "varchar", "length": 255 },
-        "Text": { "type": "varchar", "length": 255 },
-        "Building": { "type": "varchar", "length": 255 },
-        "Owner": { "type": "varchar", "length": 255 },
-        "Role": { "type": "varchar", "length": 255 },
-        "Location": { "type": "varchar", "length": 255 },
-        "Route": { "type": "varchar", "length": 255 },
-        "Email": { "type": "varchar", "length": 255 },
-        "DisplayName": { "type": "varchar", "length": 255 },
-        "Team": { "type": "varchar", "length": 255 },
-        "Username": { "type": "varchar", "length": 50 },
-        "AuthenticatedUsername": { "type": "varchar", "length": 50 },
-        "UITheme": { "type": "varchar", "length": 50 },
-        "Bio": { "type": "text" },
-        "PasswordHash": { "type": "text" },
-        "Image": { "type": "text" },
-        "AvatarURL": { "type": "text" },
-        "SQL_USER": { "type": "boolean" }
    }
 }
--- a/services/dbconnector/queryConstructor.js
+++ b/services/dbconnector/queryConstructor.js
@@ -117,14 +117,9 @@ function generateCreateQuery(dbType, table, params) {
                .map(key => `@${key}`)
                .join(', ');
            break;
-        case 'POSTGRES':
-            placeholders = Object.keys(params).map(() => '?').join(', '); // Use ? for PostgreSQL
-            break;
        case 'MARIADB':
            placeholders = Object.keys(params).map(() => `?`).join(', '); // Use ? for MariaDB
            break;
-        case 'ORACLE':
-            throw new Error('CREATE operation is not supported for ORACLE in this implementation.');
        default:
            throw new Error('Unsupported database type for this operation!');     
    }
@@ -161,22 +156,6 @@ function generateReadQuery(dbType, table, params) {
                        condition = `${key} = @${key}`;
                    }
                    break;
-                case 'ORACLE':
-                    if (params.partialMatch) {
-                        condition = `${key} LIKE '%' || :${key} || '%'`;
-                        params[key] = `%${params[key]}%`; // Add % wildcard in params
-                    } else {
-                        condition = `${key} = :${key}`;
-                    }
-                    break;
-                case 'POSTGRES':
-                    if (params.partialMatch) {
-                        condition = `${key} LIKE $1`;
-                        params[key] = `%${params[key]}%`; // Add % wildcard in params
-                    } else {
-                        condition = `${key} = $1`;
-                    }
-                    break;
                case 'MARIADB':
                    if (params.partialMatch) {
                        condition = `${key} LIKE ?`;
@@ -231,9 +210,6 @@ async function generateUpdateQuery(dbType, table, params) {
        case 'MSSQL':
            whereClause = `WHERE ID = @ID`;
            break;
-        case 'POSTGRES':
-            whereClause = `WHERE ID = $2`;
-            break;
        case 'MARIADB':
            whereClause = `WHERE ID = ?`;
            break;
@@ -258,12 +234,8 @@ async function generateDeleteQuery(dbType, table, params) {
    switch (dbType.toUpperCase()) {
        case 'MSSQL':
            return `DELETE FROM ${table} WHERE ID = @ID;`;
-        case 'POSTGRES':
-            return `DELETE FROM ${table} WHERE ID = $1;`; // Use $1 for PostgreSQL
        case 'MARIADB':
            return `DELETE FROM ${table} WHERE ID = ?;`;
-        case 'ORACLE':
-            throw new Error('DELETE operation is not supported for ORACLE in this implementation.');
        default:
            throw new Error('Unsupported database type!');
    }
@@ -279,57 +251,10 @@ async function generateTestQuery(dbType) {
    switch (dbType.toUpperCase()) {
        case 'MSSQL':
            return `SELECT @@SPID;`;
-        case 'POSTGRES':
-            return `SELECT pg_backend_pid();`; // Use $1 for PostgreSQL
        case 'MARIADB':
            return `SELECT CONNECTION_ID();`;
-        case 'ORACLE':
-            return `SELECT SYS_CONTEXT('USERENV', 'SESSIONID') FROM dual;`;
        default:
            throw new Error('Unsupported database type!');
    }
 }
-/*
-*
-* I intend to implement "compare" functionality but haven't yet decided how to do so. This is some spitballed code that I came up with for this exercise, and I hope to complete work on it in the future.
-/**
- * Generates a COMPARE SQL query string based on database type, table, and parameters.
- *
- * @param {string} dbType - Type of database (e.g., 'MSSQL', 'ORACLE').
- * @param {Object} params - Parameters for the SQL query.
- * @returns {string} The constructed COMPARE SQL query string.
- *
-function generateCompareQuery(dbType, table, params) {
-    const { compareTable, idField } = params;
-    
-    switch (dbType.toUpperCase()) {
-        case 'MSSQL':
-            return `
-                SELECT a.*
-                FROM ${table} a
-                JOIN ${compareTable} b ON a.${idField} = b.${idField}
-            `;
-        case 'ORACLE':
-            return `
-                SELECT a.*
-                FROM ${table} a
-                JOIN ${compareTable} b ON a.${idField} = b.${idField}
-            `;
-        case 'POSTGRES':
-            return `
-                SELECT a.*
-                FROM ${table} a
-                JOIN ${compareTable} b ON a.${idField} = b.${idField}
-            `;
-        case 'MARIADB':
-            return `
-                SELECT a.*
-                FROM ${table} a
-                JOIN ${compareTable} b ON a.${idField} = b.${idField}
-            `;
-        default:
-            throw new Error('Unsupported database type');
-    }
-}*/
-
 module.exports = { generateQuery };
--- a/services/dbconnector/queryExecutor.js
+++ b/services/dbconnector/queryExecutor.js
@@ -32,21 +32,11 @@ async function executeQuery(table, operation, params) {
                console.log('Formatted parameters for MSSQL:', formattedParams); // Log the formatted parameters
                result = await executeMSSQLQuery(connection, query, formattedParams);
                break;
-            case 'ORACLE':
-                console.log('Executing Oracle query:', query); // Debugging log
-                console.log('Formatted parameters for Oracle:', formattedParams); // Log the formatted parameters
-                result = await executeOracleQuery(connection, query, formattedParams);
-                break;
            case 'MARIADB':
                console.log('Executing MariaDB query:', query); // Debugging log
                console.log('Formatted parameters for MariaDB:', formattedParams); // Log the formatted parameters
                result = await executeMariaDBQuery(connection, query, formattedParams);
                break;
-            case 'POSTGRES':
-                console.log('Executing PostgreSQL query:', query); // Debugging log
-                console.log('Formatted parameters for PostgreSQL:', formattedParams); // Log the formatted parameters
-                result = await executePostgresQuery(connection, query, formattedParams);
-                break;
            default:
                throw new Error('Unsupported database type');
        }
@@ -91,30 +81,6 @@ async function executeMSSQLQuery(connection, query, params) {
    }
 }

-async function executeOracleQuery(connection, query, params) {
-    const binds = {};
-
-    // Bind each parameter with its name and value
-    Object.keys(params).forEach((key, index) => {
-        binds[`param${index + 1}`] = { type: params[key].type, val: params[key].value };
-    });
-
-    const options = {
-        outFormat: require('oracledb').OUT_FORMAT_OBJECT
-    };
-
-    try {
-        console.log('Executing Oracle query:', query); // Debugging log
-        console.log('Binding parameters for Oracle:', binds); // Debugging log
-        const result = await connection.execute(query, binds, options);
-        return { recordset: result.rows, affectedRows: result.rowsAffected };
-
-    } catch (error) {
-        console.error('Error executing Oracle query:', error.message);
-        throw error;
-    }
-}
-
 async function executeMariaDBQuery(connection, query, params) {
    try {
        // Extract parameter values in order
@@ -130,20 +96,4 @@ async function executeMariaDBQuery(connection, query, params) {
    }
 }

-async function executePostgresQuery(connection, query, params) {
-    try {
-        // Extract parameter values in order
-        const paramValues = Object.keys(params).map(key => params[key].value);
-
-        console.log('Executing PostgreSQL query:', query); // Debugging log
-        console.log('Binding parameters for PostgreSQL:', paramValues); // Debugging log
-
-        const result = await connection.query(query, paramValues);
-        return { recordset: result.rows };
-    } catch (error) {
-        console.error('Error executing PostgreSQL query:', error.message);
-        throw error;
-    }
-}
-
 module.exports = { executeQuery };