@praise25/mcp-server-mysql 1.0.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,405 @@
+#!/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, } from "./src/config/index.js";
+import { safeExit, getPool, executeQuery, executeVerifiedQuery, poolPromise, } from "./src/db/index.js";
+import path from 'path';
+import express from "express";
+import { fileURLToPath } from 'url';
+import crypto from 'crypto';
+import helmet from 'helmet';
+log("info", `Starting MySQL MCP server v${version}...`);
+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)";
+}
+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: process.env.MYSQL_SSL === "true" ? "enabled" : "disabled",
+    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, with '?' as placeholders for parameters.",
+                            },
+                            params: {
+                                type: "array",
+                                description: "An array of parameters to bind to the placeholders in the SQL query.",
+                                items: {
+                                    type: "string",
+                                }
+                            }
+                        },
+                        required: ["sql", "params"],
+                    },
+                },
+            },
+        },
+    });
+    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 executeVerifiedQuery(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 { sql, params } = request.params.arguments;
+            return await executeVerifiedQuery(sql, params);
+        }
+        catch (err) {
+            const error = err;
+            log("error", "Error in CallToolRequest handler:", error);
+            const message = process.env.DEBUG === 'true' ? error.message : "An internal error occurred while processing the tool call.";
+            return {
+                content: [{
+                        type: "text",
+                        text: `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, with '?' as placeholders for parameters.",
+                            },
+                            params: {
+                                type: "array",
+                                description: "An array of parameters to bind to the placeholders in the SQL query.",
+                                items: {
+                                    type: "string",
+                                }
+                            }
+                        },
+                        required: ["sql", "params"],
+                    },
+                },
+            ],
+        };
+        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 = path.resolve(process.argv[1]);
+        return currentModulePath === mainScriptPath;
+    }
+    return false;
+};
+if (isMainModule()) {
+    log("info", "Running in standalone mode");
+    if (IS_REMOTE_MCP && !REMOTE_SECRET_KEY) {
+        log("error", "FATAL: Server is configured for remote mode (IS_REMOTE_MCP=true) but no REMOTE_SECRET_KEY is provided.");
+        safeExit(1);
+    }
+    (async () => {
+        try {
+            const mcpServer = createMcpServer({ config: { debug: false } });
+            if (IS_REMOTE_MCP && REMOTE_SECRET_KEY?.length) {
+                const app = express();
+                app.use(helmet());
+                app.use(express.json());
+                app.post("/mcp", async (req, res) => {
+                    const authHeader = req.get("Authorization");
+                    let providedToken = "";
+                    if (authHeader && authHeader.startsWith("Bearer ")) {
+                        providedToken = authHeader.substring(7);
+                    }
+                    try {
+                        const secretBuffer = Buffer.from(REMOTE_SECRET_KEY, 'utf8');
+                        const providedTokenBuffer = Buffer.from(providedToken, 'utf8');
+                        if (secretBuffer.length !== providedTokenBuffer.length || !crypto.timingSafeEqual(secretBuffer, providedTokenBuffer)) {
+                            throw new Error("Invalid token");
+                        }
+                    }
+                    catch {
+                        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,51 @@
+import * as dotenv from "dotenv";
+import { parseSchemaPermissions } from "../utils/index.js";
+export const MCP_VERSION = "2.0.2";
+dotenv.config();
+if (process.env.NODE_ENV === "test" && !process.env.MYSQL_DB) {
+    process.env.MYSQL_DB = "mcp_test_db";
+}
+export const ALLOW_INSERT_OPERATION = process.env.ALLOW_INSERT_OPERATION === "true";
+export const ALLOW_UPDATE_OPERATION = process.env.ALLOW_UPDATE_OPERATION === "true";
+export const ALLOW_DELETE_OPERATION = process.env.ALLOW_DELETE_OPERATION === "true";
+export const ALLOW_DDL_OPERATION = process.env.ALLOW_DDL_OPERATION === "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 MYSQL_MAX_QUERY_COMPLEXITY = Number(process.env.MYSQL_MAX_QUERY_COMPLEXITY) || 1000;
+export const isMultiDbMode = !process.env.MYSQL_DB || process.env.MYSQL_DB.trim() === "";
+export const mcpConfig = {
+    server: {
+        name: "@benborla29/mcp-server-mysql",
+        version: MCP_VERSION,
+        connectionTypes: ["stdio", "streamableHttp"],
+    },
+    mysql: {
+        ...(process.env.MYSQL_SOCKET_PATH
+            ? {
+                socketPath: process.env.MYSQL_SOCKET_PATH,
+            }
+            : {
+                host: process.env.MYSQL_HOST || "127.0.0.1",
+                port: Number(process.env.MYSQL_PORT || "3306"),
+            }),
+        user: process.env.MYSQL_USER || "root",
+        password: process.env.MYSQL_PASS,
+        database: process.env.MYSQL_DB || undefined,
+        connectionLimit: 10,
+        ...(process.env.MYSQL_SSL === "true"
+            ? {
+                ssl: {
+                    rejectUnauthorized: process.env.MYSQL_SSL_REJECT_UNAUTHORIZED === "true",
+                },
+            }
+            : {}),
+    },
+    paths: {
+        schema: "schema",
+    },
+};

package/dist/src/db/index.js

@@ -0,0 +1,142 @@
+import { performance } from "perf_hooks";
+import { isMultiDbMode, MYSQL_MAX_QUERY_COMPLEXITY } from "./../config/index.js";
+import { isDDLAllowedForSchema, isInsertAllowedForSchema, isUpdateAllowedForSchema, isDeleteAllowedForSchema, } from "./permissions.js";
+import { getAllSchemasFromQuery, getQueryTypes, getAST, calculateComplexity } from "./utils.js";
+import * as mysql2 from "mysql2/promise";
+import { log } from "./../utils/index.js";
+import { mcpConfig as config } from "./../config/index.js";
+if (isMultiDbMode && process.env.MULTI_DB_WRITE_MODE !== "true") {
+    log("error", "Multi-DB mode detected - enabling read-only mode for safety");
+}
+const isTestEnvironment = process.env.NODE_ENV === "test" || process.env.VITEST;
+function safeExit(code) {
+    if (!isTestEnvironment) {
+        process.exit(code);
+    }
+    else {
+        log("error", `[Test mode] Would have called process.exit(${code})`);
+    }
+}
+let poolPromise;
+const getPool = () => {
+    if (!poolPromise) {
+        poolPromise = new Promise((resolve, reject) => {
+            try {
+                const pool = mysql2.createPool(config.mysql);
+                log("info", "MySQL pool created successfully");
+                resolve(pool);
+            }
+            catch (error) {
+                log("error", "Error creating MySQL pool:", error);
+                reject(error);
+            }
+        });
+    }
+    return poolPromise;
+};
+async function executeQuery(sql, params = []) {
+    let connection;
+    try {
+        const pool = await getPool();
+        connection = await pool.getConnection();
+        const result = await connection.query(sql, params);
+        return (Array.isArray(result) ? result[0] : result);
+    }
+    catch (error) {
+        log("error", "Error executing query:", error);
+        throw error;
+    }
+    finally {
+        if (connection) {
+            connection.release();
+            log("error", "Connection released");
+        }
+    }
+}
+async function executeVerifiedQuery(sql, params) {
+    let connection;
+    try {
+        const pool = await getPool();
+        connection = await pool.getConnection();
+        log("info", "Connection acquired for verified query");
+        const ast = getAST(sql);
+        const complexity = calculateComplexity(ast);
+        if (complexity > MYSQL_MAX_QUERY_COMPLEXITY) {
+            throw new Error(`Query is too complex to execute (complexity: ${complexity}, max: ${MYSQL_MAX_QUERY_COMPLEXITY}). Please simplify the query.`);
+        }
+        const queryTypes = await getQueryTypes(ast);
+        const schemas = getAllSchemasFromQuery(sql, ast);
+        const isUpdateOperation = queryTypes.some((type) => ["update"].includes(type));
+        const isInsertOperation = queryTypes.some((type) => ["insert"].includes(type));
+        const isDeleteOperation = queryTypes.some((type) => ["delete"].includes(type));
+        const isDDLOperation = queryTypes.some((type) => ["create", "alter", "drop", "truncate"].includes(type));
+        const isWriteOperation = isUpdateOperation || isInsertOperation || isDeleteOperation || isDDLOperation;
+        for (const schema of schemas) {
+            if (isInsertOperation && !isInsertAllowedForSchema(schema)) {
+                throw new Error(`INSERT operations are not allowed for schema '${schema || "default"}'.`);
+            }
+            if (isUpdateOperation && !isUpdateAllowedForSchema(schema)) {
+                throw new Error(`UPDATE operations are not allowed for schema '${schema || "default"}'.`);
+            }
+            if (isDeleteOperation && !isDeleteAllowedForSchema(schema)) {
+                throw new Error(`DELETE operations are not allowed for schema '${schema || "default"}'.`);
+            }
+            if (isDDLOperation && !isDDLAllowedForSchema(schema)) {
+                throw new Error(`DDL operations are not allowed for schema '${schema || "default"}'.`);
+            }
+        }
+        await connection.beginTransaction();
+        try {
+            const startTime = performance.now();
+            const [result] = await connection.query(sql, params);
+            const endTime = performance.now();
+            const duration = endTime - startTime;
+            await connection.commit();
+            let responseText = JSON.stringify(result, null, 2);
+            if (isWriteOperation) {
+                const resultHeader = result;
+                if (isInsertOperation) {
+                    responseText = `Insert successful on the relevant schema(s). Affected rows: ${resultHeader.affectedRows}, Last insert ID: ${resultHeader.insertId}`;
+                }
+                else if (isUpdateOperation) {
+                    responseText = `Update successful on the relevant schema(s). Affected rows: ${resultHeader.affectedRows}, Changed rows: ${resultHeader.changedRows || 0}`;
+                }
+                else if (isDeleteOperation) {
+                    responseText = `Delete successful on the relevant schema(s). Affected rows: ${resultHeader.affectedRows}`;
+                }
+                else if (isDDLOperation) {
+                    responseText = `DDL operation successful on the relevant schema(s).`;
+                }
+            }
+            return {
+                content: [
+                    { type: "text", text: responseText },
+                    { type: "text", text: `Query execution time: ${duration.toFixed(2)} ms` },
+                ],
+                isError: false,
+            };
+        }
+        catch (error) {
+            await connection.rollback();
+            throw error;
+        }
+    }
+    catch (error) {
+        const isSafeError = error instanceof Error && (error.message.includes("not allowed for schema") ||
+            error.message.includes("Query is too complex"));
+        const message = error instanceof Error ? error.message : String(error);
+        log("error", "Error in executeVerifiedQuery:", message);
+        const returnedMessage = process.env.DEBUG === 'true' || isSafeError ? message : "An internal server error occurred.";
+        return {
+            content: [{ type: "text", text: `Error: ${returnedMessage}` }],
+            isError: true,
+        };
+    }
+    finally {
+        if (connection) {
+            connection.release();
+            log("info", "Connection released");
+        }
+    }
+}
+export { isTestEnvironment, safeExit, executeQuery, getPool, executeVerifiedQuery, poolPromise, };

package/dist/src/db/permissions.js

@@ -0,0 +1,34 @@
+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, } from "../config/index.js";
+function isInsertAllowedForSchema(schema) {
+    if (!schema) {
+        return ALLOW_INSERT_OPERATION;
+    }
+    return schema in SCHEMA_INSERT_PERMISSIONS
+        ? SCHEMA_INSERT_PERMISSIONS[schema]
+        : ALLOW_INSERT_OPERATION;
+}
+function isUpdateAllowedForSchema(schema) {
+    if (!schema) {
+        return ALLOW_UPDATE_OPERATION;
+    }
+    return schema in SCHEMA_UPDATE_PERMISSIONS
+        ? SCHEMA_UPDATE_PERMISSIONS[schema]
+        : ALLOW_UPDATE_OPERATION;
+}
+function isDeleteAllowedForSchema(schema) {
+    if (!schema) {
+        return ALLOW_DELETE_OPERATION;
+    }
+    return schema in SCHEMA_DELETE_PERMISSIONS
+        ? SCHEMA_DELETE_PERMISSIONS[schema]
+        : ALLOW_DELETE_OPERATION;
+}
+function isDDLAllowedForSchema(schema) {
+    if (!schema) {
+        return ALLOW_DDL_OPERATION;
+    }
+    return schema in SCHEMA_DDL_PERMISSIONS
+        ? SCHEMA_DDL_PERMISSIONS[schema]
+        : ALLOW_DDL_OPERATION;
+}
+export { isInsertAllowedForSchema, isUpdateAllowedForSchema, isDeleteAllowedForSchema, isDDLAllowedForSchema, };