Electron.js 应用中安全地访问 SQL 数据库：构建可靠的后端通信层

// renderer.js
const loginForm = document.getElementById('login-form');
const usernameInput = document.getElementById('username');
const passwordInput = document.getElementById('password');

loginForm.addEventListener('submit', async (event) => {
    event.preventDefault();

    const username = usernameInput.value;
    const password = passwordInput.value;

    try {
        // 使用预加载脚本暴露的 API 调用主进程
        const isSuccess = await window.GlobalApi.invoke('login', { username, password });
        displayLoginStatus(isSuccess);
    } catch (error) {
        console.error('Login failed:', error);
        displayLoginStatus(false, 'An error occurred during login.');
    }
});

function displayLoginStatus(isSuccess, message = '') {
    const existingMessage = loginForm.querySelector('.status-message');
    if (existingMessage) {
        loginForm.removeChild(existingMessage);
    }

    const statusMessage = document.createElement('p');
    statusMessage.classList.add('status-message');

    if (isSuccess) {
        statusMessage.textContent = 'Login successful!';
        statusMessage.style.color = 'green';
    } else {
        statusMessage.textContent = message || 'Incorrect details.';
        statusMessage.style.color = 'red';
    }
    loginForm.appendChild(statusMessage);

    setTimeout(() => {
        if (loginForm.contains(statusMessage)) {
            loginForm.removeChild(statusMessage);
        }
    }, 3000);
}

// preload.js
const { contextBridge, ipcRenderer } = require('electron');

// 封装 ipcRenderer.invoke 用于向主进程发送请求并等待响应
const invoke = (channel, args) => {
    return ipcRenderer.invoke(channel, args);
};

// 封装 ipcRenderer.on 用于监听主进程发送的事件
const handle = (channel, cb) => {
    ipcRenderer.on(channel, (event, ...args) => cb(event, ...args));
};

// 通过 contextBridge 将封装后的 API 暴露给渲染进程
contextBridge.exposeInMainWorld("GlobalApi", {
    invoke: invoke,
    handle: handle
});

// 注意：原问题中的 myCoolApi 和 dbFunctions.readSomeDatafromDB 
// 在新架构下不再需要直接暴露给渲染进程，因为数据库操作将通过后端服务完成。
// 如果需要从数据库获取数据，也应通过 GlobalApi.invoke 发送请求到主进程，
// 主进程再通过后端服务获取。

// main.js
const { app, BrowserWindow, ipcMain } = require('electron');
const path = require('path');
const axios = require('axios'); // 用于向后端服务发起 HTTP 请求

let mainWindow;

// 后端服务的地址
const BACKEND_API_URL = 'http://localhost:3000/api'; // 根据你的后端服务地址进行修改

function createWindow() {
    mainWindow = new BrowserWindow({
        width: 800,
        height: 600,
        webPreferences: {
            // 注意：在生产环境中应禁用 nodeIntegration 和 contextIsolation: false，
            // 并确保 preload 脚本是安全的。这里为了演示方便，沿用原问题设置。
            nodeIntegration: false, // 强烈建议设置为 false
            contextIsolation: true, // 强烈建议设置为 true
            preload: path.join(__dirname, 'preload.js')
        },
    });

    mainWindow.loadFile(path.join(__dirname, 'index.html'));

    mainWindow.on('closed', () => {
        mainWindow = null;
    });

    // 打开开发者工具
    // mainWindow.webContents.openDevTools();
}

app.on('ready', createWindow);

app.on('window-all-closed', () => {
    if (process.platform !== 'darwin') {
        app.quit();
    }
});

app.on('activate', () => {
    if (mainWindow === null) {
        createWindow();
    }
});

// 监听渲染进程发来的 'login' 请求
ipcMain.handle('login', async (event, loginData) => {
    const { username, password } = loginData;
    console.log(`Received login request from renderer. Username: ${username}`);

    try {
        // 向后端服务发送登录请求
        const response = await axios.post(`${BACKEND_API_URL}/login`, { username, password });

        // 假设后端返回 { success: true/false }
        return response.data.success; 
    } catch (error) {
        console.error('Error communicating with backend API:', error.message);
        // 根据错误类型返回不同的状态，或者统一返回失败
        return false; 
    }
});

// 移除原问题中直接连接数据库的代码 (tedious, Connection, Request等)
// 它们将由后端服务处理。

backend/
├── server.js
├── package.json
└── .env  (存放敏感凭证，不应提交到版本控制)

// backend/server.js
require('dotenv').config(); // 加载 .env 文件中的环境变量
const express = require('express');
const bodyParser = require('body-parser');
const Connection = require('tedious').Connection;
const Request = require('tedious').Request;
const TYPES = require('tedious').TYPES;
const cors = require('cors'); // 用于允许 Electron 应用跨域访问

const app = express();
const PORT = process.env.PORT || 3000;

app.use(bodyParser.json());
app.use(cors()); // 允许所有来源的请求，生产环境应配置特定白名单

// 数据库连接配置
const dbConfig = {
    server: process.env.DB_SERVER,
    authentication: {
        type: 'default',
        options: {
            userName: process.env.DB_USERNAME,
            password: process.env.DB_PASSWORD
        }
    },
    options: {
        encrypt: process.env.DB_ENCRYPT === 'true', // 例如，Azure SQL 需要加密
        database: process.env.DB_DATABASE,
        trustServerCertificate: process.env.DB_TRUST_SERVER_CERTIFICATE === 'true' // 如果是自签名证书或开发环境
    }
};

// 登录 API 路由
app.post('/api/login', (req, res) => {
    const { username, password } = req.body;

    if (!username || !password) {
        return res.status(400).json({ success: false, message: 'Username and password are required.' });
    }

    const connection = new Connection(dbConfig);

    connection.on('connect', (err) => {
        if (err) {
            console.error('Database connection error:', err.message);
            return res.status(500).json({ success: false, message: 'Database connection failed.' });
        }
        console.log('Connected to SQL Server.');

        // 使用参数化查询防止 SQL 注入
        const request = new Request(
            "SELECT COUNT(*) AS userCount FROM Users WHERE username = @username AND password = @password", // 假设有一个 Users 表
            (err, rowCount) => {
                if (err) {
                    console.error('SQL query error:', err.message);
                    connection.close();
                    return res.status(500).json({ success: false, message: 'Login query failed.' });
                }
                // rowCount 是受影响的行数，对于 SELECT COUNT(*) 来说，通常是 1
                // 但我们需要从 row 事件中获取实际的 userCount 值
            }
        );

        request.addParameter('username', TYPES.NVarChar, username);
        request.addParameter('password', TYPES.NVarChar, password); // 注意：实际应用中密码应哈希存储和比较

        let userFound = false;
        request.on('row', (columns) => {
            columns