@zilosoft/mcp-server-mysql 2.1.0

package/dist/evals.js

@@ -0,0 +1,32 @@
+import { openai } from "@ai-sdk/openai";
+import { grade } from "mcp-evals";
+const mysqlQueryToolEval = {
+    name: 'mysql_query Tool Evaluation',
+    description: 'Evaluates the MySQL query execution functionality',
+    run: async () => {
+        const result = await grade(openai("gpt-4"), "Please execute the following SQL query and return the results: SELECT * FROM employees WHERE status='ACTIVE';");
+        return JSON.parse(result);
+    }
+};
+const mysqlQueryGenerationEval = {
+    name: 'mysql_query Tool Generation Evaluation',
+    description: 'Evaluates the MySQL query tool for correct SQL generation and execution',
+    run: async () => {
+        const result = await grade(openai("gpt-4"), "Use the mysql_query tool to select all rows from the 'users' table where isActive = 1. Provide the SQL query in the correct format.");
+        return JSON.parse(result);
+    }
+};
+const mysqlQueryColumnsEval = {
+    name: 'mysql_query Columns Evaluation',
+    description: 'Evaluates the mysql_query tool for column selection',
+    run: async () => {
+        const result = await grade(openai("gpt-4"), "Please provide a SQL query to retrieve the id, name, and email columns for all records in the users table.");
+        return JSON.parse(result);
+    }
+};
+const config = {
+    model: openai("gpt-4"),
+    evals: [mysqlQueryToolEval, mysqlQueryGenerationEval, mysqlQueryColumnsEval]
+};
+export default config;
+export const evals = [mysqlQueryToolEval, mysqlQueryGenerationEval, mysqlQueryColumnsEval];

package/dist/index.js

@@ -0,0 +1,417 @@
+#!/usr/bin/env node
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { CallToolRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { z } from "zod";
+import { log } from "./src/utils/index.js";
+import { ALLOW_DELETE_OPERATION, ALLOW_DDL_OPERATION, ALLOW_INSERT_OPERATION, ALLOW_UPDATE_OPERATION, SCHEMA_DELETE_PERMISSIONS, SCHEMA_DDL_PERMISSIONS, SCHEMA_INSERT_PERMISSIONS, SCHEMA_UPDATE_PERMISSIONS, isMultiDbMode, mcpConfig as config, MCP_VERSION as version, IS_REMOTE_MCP, REMOTE_SECRET_KEY, PORT, IS_SSL_ENABLED, IS_SSL_AUTO_DETECTED, IS_SSL_SKIP_VERIFY, } from "./src/config/index.js";
+import { safeExit, getPool, executeQuery, executeReadOnlyQuery, poolPromise, } from "./src/db/index.js";
+import express from "express";
+import { fileURLToPath } from 'url';
+import { realpathSync } from 'fs';
+import { timingSafeEqual } from 'crypto';
+log("info", `Starting MySQL MCP server v${version}...`);
+if (IS_SSL_AUTO_DETECTED) {
+    log("info", "SSL auto-detected: remote host, enabling encrypted connection. " +
+        "Set MYSQL_SSL=false to disable.");
+}
+if (IS_SSL_SKIP_VERIFY) {
+    log("error", "WARNING: SSL certificate verification is DISABLED (MYSQL_SSL_SKIP_VERIFY=true). " +
+        "Connection is vulnerable to MITM attacks. Provide MYSQL_SSL_CA for verified SSL.");
+}
+const toolVersion = `MySQL MCP Server [v${process.env.npm_package_version}]`;
+let toolDescription = `[${toolVersion}] Run SQL queries against MySQL database`;
+if (isMultiDbMode) {
+    toolDescription += " (Multi-DB mode enabled)";
+}
+if (ALLOW_INSERT_OPERATION ||
+    ALLOW_UPDATE_OPERATION ||
+    ALLOW_DELETE_OPERATION ||
+    ALLOW_DDL_OPERATION) {
+    toolDescription += " with support for:";
+    if (ALLOW_INSERT_OPERATION) {
+        toolDescription += " INSERT,";
+    }
+    if (ALLOW_UPDATE_OPERATION) {
+        toolDescription += " UPDATE,";
+    }
+    if (ALLOW_DELETE_OPERATION) {
+        toolDescription += " DELETE,";
+    }
+    if (ALLOW_DDL_OPERATION) {
+        toolDescription += " DDL,";
+    }
+    toolDescription = toolDescription.replace(/,$/, "") + " and READ operations";
+    if (Object.keys(SCHEMA_INSERT_PERMISSIONS).length > 0 ||
+        Object.keys(SCHEMA_UPDATE_PERMISSIONS).length > 0 ||
+        Object.keys(SCHEMA_DELETE_PERMISSIONS).length > 0 ||
+        Object.keys(SCHEMA_DDL_PERMISSIONS).length > 0) {
+        toolDescription += " (Schema-specific permissions enabled)";
+    }
+}
+else {
+    toolDescription += " (READ-ONLY)";
+}
+const isReadOnly = !(ALLOW_INSERT_OPERATION ||
+    ALLOW_UPDATE_OPERATION ||
+    ALLOW_DELETE_OPERATION ||
+    ALLOW_DDL_OPERATION);
+log("info", "MySQL Configuration:", JSON.stringify({
+    ...(process.env.MYSQL_SOCKET_PATH
+        ? {
+            socketPath: process.env.MYSQL_SOCKET_PATH,
+            connectionType: "Unix Socket",
+        }
+        : {
+            host: process.env.MYSQL_HOST || "127.0.0.1",
+            port: process.env.MYSQL_PORT || "3306",
+            connectionType: "TCP/IP",
+        }),
+    user: config.mysql.user,
+    password: config.mysql.password ? "******" : "not set",
+    database: config.mysql.database || "MULTI_DB_MODE",
+    ssl: IS_SSL_ENABLED
+        ? `enabled${IS_SSL_AUTO_DETECTED ? " (auto-detected: remote host)" : ""}` +
+            `, verification: ${IS_SSL_SKIP_VERIFY ? "DISABLED" : "strict"}`
+        : "disabled",
+    sslCA: process.env.MYSQL_SSL_CA ? "set" : "not set",
+    sslCert: process.env.MYSQL_SSL_CERT ? "set" : "not set",
+    sslKey: process.env.MYSQL_SSL_KEY ? "set" : "not set",
+    multiDbMode: isMultiDbMode ? "enabled" : "disabled",
+}, null, 2));
+export const configSchema = z.object({
+    debug: z.boolean().default(false).describe("Enable debug logging"),
+});
+export default function createMcpServer({ sessionId, config, }) {
+    const server = new Server({
+        name: "MySQL MCP Server",
+        version: process.env.npm_package_version || "1.0.0",
+    }, {
+        capabilities: {
+            resources: {},
+            tools: {
+                mysql_query: {
+                    description: toolDescription,
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            sql: {
+                                type: "string",
+                                description: "The SQL query to execute",
+                            },
+                        },
+                        required: ["sql"],
+                    },
+                    annotations: {
+                        readOnlyHint: isReadOnly,
+                        idempotentHint: isReadOnly,
+                        destructiveHint: !isReadOnly,
+                        openWorldHint: false,
+                        title: "MySQL Query",
+                    },
+                },
+            },
+        },
+    });
+    server.setRequestHandler(ListResourcesRequestSchema, async () => {
+        try {
+            log("info", "Handling ListResourcesRequest");
+            const connectionInfo = process.env.MYSQL_SOCKET_PATH
+                ? `socket: ${process.env.MYSQL_SOCKET_PATH}`
+                : `host: ${process.env.MYSQL_HOST || "localhost"}, port: ${process.env.MYSQL_PORT || 3306}`;
+            log("info", `Connection info: ${connectionInfo}`);
+            const tablesQuery = `
+      SELECT
+        table_name as name,
+        table_schema as \`database\`,
+        table_comment as description,
+        table_rows as rowCount,
+        data_length as dataSize,
+        index_length as indexSize,
+        create_time as createTime,
+        update_time as updateTime
+      FROM
+        information_schema.tables
+      WHERE
+        table_schema NOT IN ('information_schema', 'mysql', 'performance_schema', 'sys')
+      ORDER BY
+        table_schema, table_name
+    `;
+            const queryResult = (await executeReadOnlyQuery(tablesQuery));
+            const tables = JSON.parse(queryResult.content[0].text);
+            log("info", `Found ${tables.length} tables`);
+            const resources = tables.map((table) => ({
+                uri: `mysql://tables/${table.name}`,
+                name: table.name,
+                title: `${table.database}.${table.name}`,
+                description: table.description ||
+                    `Table ${table.name} in database ${table.database}`,
+                mimeType: "application/json",
+            }));
+            resources.push({
+                uri: "mysql://tables",
+                name: "Tables",
+                title: "MySQL Tables",
+                description: "List of all MySQL tables",
+                mimeType: "application/json",
+            });
+            return { resources };
+        }
+        catch (error) {
+            log("error", "Error in ListResourcesRequest handler:", error);
+            throw error;
+        }
+    });
+    server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+        try {
+            log("info", "Handling ReadResourceRequest:", request.params.uri);
+            const uriParts = request.params.uri.split("/");
+            const tableName = uriParts.pop();
+            const dbName = uriParts.length > 0 ? uriParts.pop() : null;
+            if (!tableName) {
+                throw new Error(`Invalid resource URI: ${request.params.uri}`);
+            }
+            let columnsQuery = "SELECT column_name, data_type FROM information_schema.columns WHERE table_name = ?";
+            let queryParams = [tableName];
+            if (dbName) {
+                columnsQuery += " AND table_schema = ?";
+                queryParams.push(dbName);
+            }
+            const results = (await executeQuery(columnsQuery, queryParams));
+            return {
+                contents: [
+                    {
+                        uri: request.params.uri,
+                        mimeType: "application/json",
+                        text: JSON.stringify(results, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            log("error", "Error in ReadResourceRequest handler:", error);
+            throw error;
+        }
+    });
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        try {
+            log("info", "Handling CallToolRequest:", request.params.name);
+            if (request.params.name !== "mysql_query") {
+                throw new Error(`Unknown tool: ${request.params.name}`);
+            }
+            const sqlValidation = z.string().min(1, "sql must be a non-empty string").safeParse(request.params.arguments?.sql);
+            if (!sqlValidation.success) {
+                return {
+                    content: [{ type: "text", text: `Error: ${sqlValidation.error.issues[0].message}` }],
+                    isError: true,
+                };
+            }
+            const sql = sqlValidation.data;
+            return await executeReadOnlyQuery(sql);
+        }
+        catch (err) {
+            const error = err;
+            log("error", "Error in CallToolRequest handler:", error);
+            return {
+                content: [{
+                        type: "text",
+                        text: `Error: ${error.message}`
+                    }],
+                isError: true
+            };
+        }
+    });
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        log("info", "Handling ListToolsRequest");
+        const toolsResponse = {
+            tools: [
+                {
+                    name: "mysql_query",
+                    description: toolDescription,
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            sql: {
+                                type: "string",
+                                description: "The SQL query to execute",
+                            },
+                        },
+                        required: ["sql"],
+                    },
+                    annotations: {
+                        readOnlyHint: isReadOnly,
+                        idempotentHint: isReadOnly,
+                        destructiveHint: !isReadOnly,
+                        openWorldHint: false,
+                        title: "MySQL Query",
+                    },
+                },
+            ],
+        };
+        log("info", "ListToolsRequest response:", JSON.stringify(toolsResponse, null, 2));
+        return toolsResponse;
+    });
+    (async () => {
+        try {
+            log("info", "Attempting to test database connection...");
+            const pool = await getPool();
+            const connection = await pool.getConnection();
+            log("info", "Database connection test successful");
+            connection.release();
+        }
+        catch (error) {
+            log("error", "Fatal error during server startup:", error);
+            safeExit(1);
+        }
+    })();
+    const shutdown = async (signal) => {
+        log("error", `Received ${signal}. Shutting down...`);
+        try {
+            if (poolPromise) {
+                const pool = await poolPromise;
+                await pool.end();
+            }
+        }
+        catch (err) {
+            log("error", "Error closing pool:", err);
+            throw err;
+        }
+    };
+    process.on("SIGINT", async () => {
+        try {
+            await shutdown("SIGINT");
+            process.exit(0);
+        }
+        catch (err) {
+            log("error", "Error during SIGINT shutdown:", err);
+            safeExit(1);
+        }
+    });
+    process.on("SIGTERM", async () => {
+        try {
+            await shutdown("SIGTERM");
+            process.exit(0);
+        }
+        catch (err) {
+            log("error", "Error during SIGTERM shutdown:", err);
+            safeExit(1);
+        }
+    });
+    process.on("uncaughtException", (error) => {
+        log("error", "Uncaught exception:", error);
+        safeExit(1);
+    });
+    process.on("unhandledRejection", (reason, promise) => {
+        log("error", "Unhandled rejection at:", promise, "reason:", reason);
+        safeExit(1);
+    });
+    return server;
+}
+const isMainModule = () => {
+    if (typeof require !== 'undefined' && require.main === module) {
+        return true;
+    }
+    if (typeof import.meta !== 'undefined' && import.meta.url && process.argv[1]) {
+        const currentModulePath = fileURLToPath(import.meta.url);
+        const mainScriptPath = realpathSync(process.argv[1]);
+        return currentModulePath === mainScriptPath;
+    }
+    return false;
+};
+if (isMainModule()) {
+    log("info", "Running in standalone mode");
+    (async () => {
+        try {
+            const mcpServer = createMcpServer({ config: { debug: false } });
+            if (IS_REMOTE_MCP && REMOTE_SECRET_KEY?.length) {
+                const app = express();
+                app.use(express.json());
+                app.post("/mcp", async (req, res) => {
+                    const authHeader = req.get("Authorization") ?? "";
+                    const expectedHeader = `Bearer ${REMOTE_SECRET_KEY}`;
+                    const authBuf = Buffer.from(authHeader);
+                    const expectedBuf = Buffer.from(expectedHeader);
+                    const authValid = authBuf.length === expectedBuf.length &&
+                        timingSafeEqual(authBuf, expectedBuf);
+                    if (!authValid) {
+                        console.error("Missing or invalid Authorization header");
+                        res.status(401).json({
+                            jsonrpc: "2.0",
+                            error: {
+                                code: -32603,
+                                message: "Missing or invalid Authorization header",
+                            },
+                            id: null,
+                        });
+                        return;
+                    }
+                    try {
+                        const server = mcpServer;
+                        const transport = new StreamableHTTPServerTransport({
+                            sessionIdGenerator: undefined,
+                        });
+                        res.on("close", () => {
+                            log("info", "Request closed");
+                            transport.close();
+                            server.close();
+                        });
+                        await server.connect(transport);
+                        await transport.handleRequest(req, res, req.body);
+                    }
+                    catch (error) {
+                        log("error", "Error handling MCP request:", error);
+                        if (!res.headersSent) {
+                            res.status(500).json({
+                                jsonrpc: "2.0",
+                                error: {
+                                    code: -32603,
+                                    message: error.message,
+                                },
+                                id: null,
+                            });
+                        }
+                    }
+                });
+                app.get("/mcp", async (req, res) => {
+                    console.log("Received GET MCP request");
+                    res.writeHead(405).end(JSON.stringify({
+                        jsonrpc: "2.0",
+                        error: {
+                            code: -32000,
+                            message: "Method not allowed.",
+                        },
+                        id: null,
+                    }));
+                });
+                app.delete("/mcp", async (req, res) => {
+                    console.log("Received DELETE MCP request");
+                    res.writeHead(405).end(JSON.stringify({
+                        jsonrpc: "2.0",
+                        error: {
+                            code: -32000,
+                            message: "Method not allowed.",
+                        },
+                        id: null,
+                    }));
+                });
+                app.listen(PORT, (error) => {
+                    if (error) {
+                        console.error("Failed to start server:", error);
+                        process.exit(1);
+                    }
+                    console.log(`MCP Stateless Streamable HTTP Server listening on port ${PORT}`);
+                });
+            }
+            else {
+                const transport = new StdioServerTransport();
+                await mcpServer.connect(transport);
+                log("info", "Server started and listening on stdio");
+            }
+        }
+        catch (error) {
+            log("error", "Server error:", error);
+            safeExit(1);
+        }
+    })();
+}

package/dist/src/config/index.js

@@ -0,0 +1,151 @@
+import * as dotenv from "dotenv";
+import * as fs from "fs";
+import { parseSchemaPermissions, parseMySQLConnectionString } from "../utils/index.js";
+function readSSLFile(filePath, label) {
+    try {
+        if (!fs.existsSync(filePath)) {
+            throw new Error(`SSL ${label} file not found: ${filePath}`);
+        }
+        const data = fs.readFileSync(filePath);
+        if (data.length === 0) {
+            throw new Error(`SSL ${label} file is empty: ${filePath}`);
+        }
+        return data;
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            if (error.message.startsWith('SSL ')) {
+                throw error;
+            }
+            throw new Error(`Failed to read SSL ${label}: ${error.message}`);
+        }
+        throw error;
+    }
+}
+function readCACertificate(filePath) {
+    return readSSLFile(filePath, 'CA certificate');
+}
+export const MCP_VERSION = "2.0.2";
+dotenv.config();
+const connectionStringConfig = process.env.MYSQL_CONNECTION_STRING
+    ? parseMySQLConnectionString(process.env.MYSQL_CONNECTION_STRING)
+    : {};
+if (process.env.NODE_ENV === "test" && !process.env.MYSQL_DB) {
+    process.env.MYSQL_DB = "mcp_test_db";
+}
+const dbFromEnvOrConnStringEarly = connectionStringConfig.database || process.env.MYSQL_DB;
+const isMultiDbModeEarly = !dbFromEnvOrConnStringEarly || dbFromEnvOrConnStringEarly.trim() === "";
+const MULTI_DB_WRITE_MODE = process.env.MULTI_DB_WRITE_MODE === "true";
+const multiDbBlocksWrites = isMultiDbModeEarly && !MULTI_DB_WRITE_MODE;
+export const ALLOW_INSERT_OPERATION = !multiDbBlocksWrites && process.env.ALLOW_INSERT_OPERATION === "true";
+export const ALLOW_UPDATE_OPERATION = !multiDbBlocksWrites && process.env.ALLOW_UPDATE_OPERATION === "true";
+export const ALLOW_DELETE_OPERATION = !multiDbBlocksWrites && process.env.ALLOW_DELETE_OPERATION === "true";
+export const ALLOW_DDL_OPERATION = !multiDbBlocksWrites && process.env.ALLOW_DDL_OPERATION === "true";
+export const MYSQL_DISABLE_READ_ONLY_TRANSACTIONS = process.env.MYSQL_DISABLE_READ_ONLY_TRANSACTIONS === "true";
+export const SCHEMA_INSERT_PERMISSIONS = parseSchemaPermissions(process.env.SCHEMA_INSERT_PERMISSIONS);
+export const SCHEMA_UPDATE_PERMISSIONS = parseSchemaPermissions(process.env.SCHEMA_UPDATE_PERMISSIONS);
+export const SCHEMA_DELETE_PERMISSIONS = parseSchemaPermissions(process.env.SCHEMA_DELETE_PERMISSIONS);
+export const SCHEMA_DDL_PERMISSIONS = parseSchemaPermissions(process.env.SCHEMA_DDL_PERMISSIONS);
+export const IS_REMOTE_MCP = process.env.IS_REMOTE_MCP === "true";
+export const REMOTE_SECRET_KEY = process.env.REMOTE_SECRET_KEY || "";
+export const PORT = process.env.PORT || 3000;
+export const isMultiDbMode = isMultiDbModeEarly;
+function shouldAutoEnableSSL() {
+    if (connectionStringConfig.ssl !== undefined) {
+        return connectionStringConfig.ssl;
+    }
+    if (process.env.MYSQL_SSL !== undefined) {
+        return process.env.MYSQL_SSL === "true";
+    }
+    if (connectionStringConfig.socketPath || process.env.MYSQL_SOCKET_PATH) {
+        return false;
+    }
+    const host = connectionStringConfig.host || process.env.MYSQL_HOST || "127.0.0.1";
+    const localHosts = new Set([
+        "localhost",
+        "127.0.0.1",
+        "::1",
+        "0:0:0:0:0:0:0:1",
+        "0.0.0.0",
+        "[::1]",
+    ]);
+    return !localHosts.has(host.toLowerCase());
+}
+export const IS_SSL_ENABLED = shouldAutoEnableSSL();
+export const IS_SSL_AUTO_DETECTED = process.env.MYSQL_SSL === undefined &&
+    connectionStringConfig.ssl === undefined &&
+    IS_SSL_ENABLED;
+const effectiveSSLCA = connectionStringConfig.sslCA || process.env.MYSQL_SSL_CA;
+const SSL_SKIP_VERIFY = process.env.MYSQL_SSL_SKIP_VERIFY === "true" ||
+    process.env.MYSQL_SSL_REJECT_UNAUTHORIZED === "false";
+export const IS_SSL_SKIP_VERIFY = IS_SSL_ENABLED && SSL_SKIP_VERIFY;
+if (IS_SSL_ENABLED && !effectiveSSLCA && !SSL_SKIP_VERIFY) {
+    throw new Error("SSL is enabled but neither a CA certificate nor a skip-verify flag is set.\n" +
+        "  - Provide MYSQL_SSL_CA=/path/to/ca.pem for secure verified connections, OR\n" +
+        "  - Set MYSQL_SSL_SKIP_VERIFY=true to explicitly disable certificate verification\n" +
+        "    (NOT recommended for production — vulnerable to MITM attacks).\n" +
+        (IS_SSL_AUTO_DETECTED
+            ? "SSL was auto-enabled because the host is not local. " +
+                "Set MYSQL_SSL=false to connect without encryption (also not recommended)."
+            : ""));
+}
+export const mcpConfig = {
+    server: {
+        name: "@benborla29/mcp-server-mysql",
+        version: MCP_VERSION,
+        connectionTypes: ["stdio", "streamableHttp"],
+    },
+    mysql: {
+        ...(connectionStringConfig.socketPath || process.env.MYSQL_SOCKET_PATH
+            ? {
+                socketPath: connectionStringConfig.socketPath || process.env.MYSQL_SOCKET_PATH,
+            }
+            : {
+                host: connectionStringConfig.host || process.env.MYSQL_HOST || "127.0.0.1",
+                port: connectionStringConfig.port || Number(process.env.MYSQL_PORT || "3306"),
+            }),
+        user: connectionStringConfig.user || process.env.MYSQL_USER || "root",
+        password: connectionStringConfig.password !== undefined
+            ? connectionStringConfig.password
+            : process.env.MYSQL_PASS === undefined
+                ? ""
+                : process.env.MYSQL_PASS,
+        database: connectionStringConfig.database || process.env.MYSQL_DB || undefined,
+        connectionLimit: 10,
+        waitForConnections: true,
+        queueLimit: process.env.MYSQL_QUEUE_LIMIT ? parseInt(process.env.MYSQL_QUEUE_LIMIT, 10) : 100,
+        enableKeepAlive: true,
+        keepAliveInitialDelay: 0,
+        connectTimeout: process.env.MYSQL_CONNECT_TIMEOUT ? parseInt(process.env.MYSQL_CONNECT_TIMEOUT, 10) : 10000,
+        ...(IS_SSL_ENABLED
+            ? {
+                ssl: {
+                    rejectUnauthorized: !SSL_SKIP_VERIFY,
+                    ...(effectiveSSLCA
+                        ? { ca: readCACertificate(effectiveSSLCA) }
+                        : {}),
+                    ...(process.env.MYSQL_SSL_CERT
+                        ? { cert: readSSLFile(process.env.MYSQL_SSL_CERT, 'client certificate') }
+                        : {}),
+                    ...(process.env.MYSQL_SSL_KEY
+                        ? { key: readSSLFile(process.env.MYSQL_SSL_KEY, 'client private key') }
+                        : {}),
+                },
+            }
+            : {}),
+        ...(process.env.MYSQL_TIMEZONE
+            ? {
+                timezone: process.env.MYSQL_TIMEZONE,
+            }
+            : {}),
+        ...(process.env.MYSQL_DATE_STRINGS === "true"
+            ? {
+                dateStrings: true,
+            }
+            : {}),
+    },
+    paths: {
+        schema: "schema",
+    },
+};
+export { readCACertificate, readSSLFile };