@johnroshan/universal-db-mcp 1.0.0 → 1.0.3

package/index.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
@@ -6,10 +6,15 @@ import {
   CallToolRequestSchema,
   ListToolsRequestSchema,
 } from "@modelcontextprotocol/sdk/types.js";
-import pg from "pg";
-import mysql from "mysql2/promise";
-
-const { Client: PgClient } = pg;
+import {
+  createConnection,
+  query,
+  listTables,
+  describeTable,
+  listDatabases,
+  getTableRowCount,
+  searchTable,
+} from "./lib.js";
 
 const DB_TYPE = process.env.DB_TYPE;
 const DB_HOST = process.env.DB_HOST || "localhost";
@@ -32,7 +37,7 @@ if (!DATABASE_URL && (!DB_NAME || !DB_USER)) {
 const server = new Server(
   {
     name: "universal-db-mcp",
-    version: "1.0.0",
+    version: "1.0.1",
   },
   {
     capabilities: {
@@ -41,53 +46,6 @@ const server = new Server(
   }
 );
 
-async function getConnection() {
-  if (DB_TYPE === "postgres") {
-    const client = new PgClient(
-      DATABASE_URL || {
-        host: DB_HOST,
-        port: DB_PORT || 5432,
-        database: DB_NAME,
-        user: DB_USER,
-        password: DB_PASSWORD,
-      }
-    );
-    await client.connect();
-    return {
-      client,
-      async query(sql, params = []) {
-        const result = await client.query(sql, params);
-        return result.rows;
-      },
-      async close() {
-        await client.end();
-      },
-    };
-  } else if (DB_TYPE === "mysql") {
-    const connection = await mysql.createConnection(
-      DATABASE_URL || {
-        host: DB_HOST,
-        port: DB_PORT || 3306,
-        database: DB_NAME,
-        user: DB_USER,
-        password: DB_PASSWORD,
-      }
-    );
-    return {
-      client: connection,
-      async query(sql, params = []) {
-        const [rows] = await connection.execute(sql, params);
-        return rows;
-      },
-      async close() {
-        await connection.end();
-      },
-    };
-  } else {
-    throw new Error(`Unsupported database type: ${DB_TYPE}`);
-  }
-}
-
 server.setRequestHandler(ListToolsRequestSchema, async () => {
   return {
     tools: [
@@ -184,10 +142,18 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
   let conn;
 
   try {
-    conn = await getConnection();
+    conn = await createConnection({
+      DB_TYPE,
+      DATABASE_URL,
+      DB_HOST,
+      DB_PORT,
+      DB_NAME,
+      DB_USER,
+      DB_PASSWORD,
+    });
 
     if (name === "query") {
-      const results = await conn.query(args.sql);
+      const results = await query(conn, args.sql);
       return {
         content: [
           {
@@ -206,22 +172,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     }
 
     if (name === "list_tables") {
-      let results;
-      if (DB_TYPE === "postgres") {
-        results = await conn.query(`
-          SELECT table_name, table_type
-          FROM information_schema.tables
-          WHERE table_schema = 'public'
-          ORDER BY table_name
-        `);
-      } else {
-        results = await conn.query(`
-          SELECT table_name, table_type
-          FROM information_schema.tables
-          WHERE table_schema = ?
-          ORDER BY table_name
-        `, [DB_NAME]);
-      }
+      const results = await listTables(conn);
       return {
         content: [
           {
@@ -233,32 +184,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     }
 
     if (name === "describe_table") {
-      let results;
-      if (DB_TYPE === "postgres") {
-        results = await conn.query(`
-          SELECT 
-            column_name,
-            data_type,
-            character_maximum_length,
-            is_nullable,
-            column_default
-          FROM information_schema.columns
-          WHERE table_name = $1
-          ORDER BY ordinal_position
-        `, [args.table]);
-      } else {
-        results = await conn.query(`
-          SELECT 
-            column_name,
-            data_type,
-            character_maximum_length,
-            is_nullable,
-            column_default
-          FROM information_schema.columns
-          WHERE table_schema = ? AND table_name = ?
-          ORDER BY ordinal_position
-        `, [DB_NAME, args.table]);
-      }
+      const results = await describeTable(conn, args.table);
       return {
         content: [
           {
@@ -270,17 +196,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     }
 
     if (name === "list_databases") {
-      let results;
-      if (DB_TYPE === "postgres") {
-        results = await conn.query(`
-          SELECT datname as database_name
-          FROM pg_database
-          WHERE datistemplate = false
-          ORDER BY datname
-        `);
-      } else {
-        results = await conn.query(`SHOW DATABASES`);
-      }
+      const results = await listDatabases(conn);
       return {
         content: [
           {
@@ -292,35 +208,25 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     }
 
     if (name === "table_row_count") {
-      const results = await conn.query(
-        `SELECT COUNT(*) as count FROM ${args.table}`
-      );
+      const result = await getTableRowCount(conn, args.table);
       return {
         content: [
           {
             type: "text",
-            text: JSON.stringify(results[0], null, 2),
+            text: JSON.stringify(result, null, 2),
           },
         ],
       };
     }
 
     if (name === "search_table") {
-      const limit = args.limit || 100;
-      let results;
-      
-      if (DB_TYPE === "postgres") {
-        results = await conn.query(
-          `SELECT * FROM ${args.table} WHERE ${args.column}::text ILIKE $1 LIMIT $2`,
-          [`%${args.value}%`, limit]
-        );
-      } else {
-        results = await conn.query(
-          `SELECT * FROM ${args.table} WHERE ${args.column} LIKE ? LIMIT ?`,
-          [`%${args.value}%`, limit]
-        );
-      }
-      
+      const results = await searchTable(
+        conn,
+        args.table,
+        args.column,
+        args.value,
+        args.limit
+      );
       return {
         content: [
           {

package/lib.js

@@ -0,0 +1,214 @@
+import pg from "pg";
+import mysql from "mysql2/promise";
+
+const { Client: PgClient } = pg;
+
+/**
+ * Create a database connection
+ * @param {Object} config - Database configuration
+ * @param {string} config.DB_TYPE - Database type ('postgres' or 'mysql')
+ * @param {string} config.DATABASE_URL - Connection URL (optional)
+ * @param {string} config.DB_HOST - Database host
+ * @param {number} config.DB_PORT - Database port
+ * @param {string} config.DB_NAME - Database name
+ * @param {string} config.DB_USER - Database user
+ * @param {string} config.DB_PASSWORD - Database password
+ * @returns {Promise<Object>} Connection object with query and close methods
+ */
+export async function createConnection(config) {
+  const {
+    DB_TYPE,
+    DATABASE_URL,
+    DB_HOST = "localhost",
+    DB_PORT,
+    DB_NAME,
+    DB_USER,
+    DB_PASSWORD,
+  } = config;
+
+  if (!DB_TYPE) {
+    throw new Error("DB_TYPE is required (postgres or mysql)");
+  }
+
+  if (!DATABASE_URL && (!DB_NAME || !DB_USER)) {
+    throw new Error("Either DATABASE_URL or DB_NAME and DB_USER are required");
+  }
+
+  if (DB_TYPE === "postgres") {
+    const client = new PgClient(
+      DATABASE_URL || {
+        host: DB_HOST,
+        port: DB_PORT || 5432,
+        database: DB_NAME,
+        user: DB_USER,
+        password: DB_PASSWORD,
+      }
+    );
+    await client.connect();
+    return {
+      client,
+      dbType: "postgres",
+      dbName: DB_NAME,
+      async query(sql, params = []) {
+        const result = await client.query(sql, params);
+        return result.rows;
+      },
+      async close() {
+        await client.end();
+      },
+    };
+  } else if (DB_TYPE === "mysql") {
+    const connection = await mysql.createConnection(
+      DATABASE_URL || {
+        host: DB_HOST,
+        port: DB_PORT || 3306,
+        database: DB_NAME,
+        user: DB_USER,
+        password: DB_PASSWORD,
+      }
+    );
+    return {
+      client: connection,
+      dbType: "mysql",
+      dbName: DB_NAME,
+      async query(sql, params = []) {
+        const [rows] = await connection.execute(sql, params);
+        return rows;
+      },
+      async close() {
+        await connection.end();
+      },
+    };
+  } else {
+    throw new Error(`Unsupported database type: ${DB_TYPE}`);
+  }
+}
+
+/**
+ * Execute a SQL query
+ * @param {Object} conn - Database connection
+ * @param {string} sql - SQL query
+ * @param {Array} params - Query parameters
+ * @returns {Promise<Array>} Query results
+ */
+export async function query(conn, sql, params = []) {
+  return await conn.query(sql, params);
+}
+
+/**
+ * List all tables in the database
+ * @param {Object} conn - Database connection
+ * @returns {Promise<Array>} List of tables
+ */
+export async function listTables(conn) {
+  if (conn.dbType === "postgres") {
+    return await conn.query(`
+      SELECT table_name, table_type
+      FROM information_schema.tables
+      WHERE table_schema = 'public'
+      ORDER BY table_name
+    `);
+  } else {
+    return await conn.query(
+      `
+      SELECT table_name, table_type
+      FROM information_schema.tables
+      WHERE table_schema = ?
+      ORDER BY table_name
+    `,
+      [conn.dbName]
+    );
+  }
+}
+
+/**
+ * Describe table schema
+ * @param {Object} conn - Database connection
+ * @param {string} tableName - Table name
+ * @returns {Promise<Array>} Table schema information
+ */
+export async function describeTable(conn, tableName) {
+  if (conn.dbType === "postgres") {
+    return await conn.query(
+      `
+      SELECT 
+        column_name,
+        data_type,
+        character_maximum_length,
+        is_nullable,
+        column_default
+      FROM information_schema.columns
+      WHERE table_name = $1
+      ORDER BY ordinal_position
+    `,
+      [tableName]
+    );
+  } else {
+    return await conn.query(
+      `
+      SELECT 
+        column_name,
+        data_type,
+        character_maximum_length,
+        is_nullable,
+        column_default
+      FROM information_schema.columns
+      WHERE table_schema = ? AND table_name = ?
+      ORDER BY ordinal_position
+    `,
+      [conn.dbName, tableName]
+    );
+  }
+}
+
+/**
+ * List all databases
+ * @param {Object} conn - Database connection
+ * @returns {Promise<Array>} List of databases
+ */
+export async function listDatabases(conn) {
+  if (conn.dbType === "postgres") {
+    return await conn.query(`
+      SELECT datname as database_name
+      FROM pg_database
+      WHERE datistemplate = false
+      ORDER BY datname
+    `);
+  } else {
+    return await conn.query(`SHOW DATABASES`);
+  }
+}
+
+/**
+ * Get row count for a table
+ * @param {Object} conn - Database connection
+ * @param {string} tableName - Table name
+ * @returns {Promise<Object>} Row count
+ */
+export async function getTableRowCount(conn, tableName) {
+  const results = await conn.query(`SELECT COUNT(*) as count FROM ${tableName}`);
+  return results[0];
+}
+
+/**
+ * Search table for matching records
+ * @param {Object} conn - Database connection
+ * @param {string} tableName - Table name
+ * @param {string} columnName - Column to search
+ * @param {string} value - Search value
+ * @param {number} limit - Maximum results (default: 100)
+ * @returns {Promise<Array>} Matching records
+ */
+export async function searchTable(conn, tableName, columnName, value, limit = 100) {
+  if (conn.dbType === "postgres") {
+    return await conn.query(
+      `SELECT * FROM ${tableName} WHERE ${columnName}::text ILIKE $1 LIMIT $2`,
+      [`%${value}%`, limit]
+    );
+  } else {
+    return await conn.query(
+      `SELECT * FROM ${tableName} WHERE ${columnName} LIKE ? LIMIT ?`,
+      [`%${value}%`, limit]
+    );
+  }
+}

package/package.json

@@ -1,42 +1,52 @@
 {
-    "name": "@johnroshan/universal-db-mcp",
-    "version": "1.0.0",
-    "description": "MCP server for PostgreSQL and MySQL databases - enables Claude to query your databases",
-    "main": "index.js",
-    "type": "module",
-    "bin": {
-      "universal-db-mcp": "./index.js"
-    },
-    "scripts": {
-      "start": "node index.js"
-    },
-    "keywords": [
-      "mcp",
-      "model-context-protocol",
-      "claude",
-      "database",
-      "postgresql",
-      "mysql",
-      "sql",
-      "ai",
-      "llm"
-    ],
-    "author": "John Roshan <johnroshan2255@gmail.com>",
-    "license": "MIT",
-    "repository": {
-      "type": "git",
-      "url": "https://github.com/johnroshan2255/universal-db-mcp.git"
-    },
-    "engines": {
-      "node": ">=18.0.0"
-    },
-    "files": ["index.js", "README.md", "LICENCE"],
-    "dependencies": {
-      "@modelcontextprotocol/sdk": "^1.25.1",
-      "pg": "^8.13.1",
-      "mysql2": "^3.11.5"
-    },
-    "devDependencies": {
-      "eslint": "^9.17.0"
-    }
-  }
+  "name": "@johnroshan/universal-db-mcp",
+  "version": "1.0.3",
+  "description": "MCP server for PostgreSQL and MySQL databases - enables Claude to query your databases",
+  "main": "index.js",
+  "type": "module",
+  "bin": {
+    "universal-db-mcp": "./index.js"
+  },
+  "exports": {
+    ".": "./index.js",
+    "./lib": "./lib.js"
+  },
+  "scripts": {
+    "start": "node index.js"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "claude",
+    "database",
+    "postgresql",
+    "mysql",
+    "sql",
+    "ai",
+    "llm"
+  ],
+  "author": "John Roshan <johnroshan2255@gmail.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/johnroshan2255/universal-db-mcp.git"
+  },
+  "homepage": "https://github.com/johnroshan2255/universal-db-mcp#readme",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "index.js",
+    "lib.js",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.25.1",
+    "pg": "^8.13.1",
+    "mysql2": "^3.11.5"
+  },
+  "devDependencies": {
+    "eslint": "^9.17.0"
+  }
+}