@marcelo-ochoa/server-postgres 1.0.6 → 1.0.8

package/dist/db.js

@@ -61,6 +61,9 @@ export async function initializePool(connectionString) {
     const url = new URL(`postgresql://${database}`);
     resourceBaseUrl = url;
 }
+export function isPoolInitialized() {
+    return pool !== undefined;
+}
 export function getPool() {
     if (!pool) {
         throw new Error("Postgres connection pool not initialized. Use pg-connect tool first.");

package/dist/handlers.js

@@ -1,9 +1,9 @@
-import { withConnection } from "./db.js";
 import { queryHandler } from "./tools/query.js";
 import { statsHandler } from "./tools/stats.js";
 import { connectHandler } from "./tools/connect.js";
 import { explainHandler } from "./tools/explain.js";
 import { awrHandler } from "./tools/awr.js";
+export { listResourcesHandler, readResourceHandler } from "./resources.js";
 const toolHandlers = {
     "pg-query": queryHandler,
     "pg-stats": statsHandler,
@@ -18,72 +18,3 @@ export const callToolHandler = async (request) => {
     }
     throw new Error(`Unknown tool: ${request.params.name}`);
 };
-const SCHEMA_PATH = "schema";
-export const listResourcesHandler = async (request) => {
-    return await withConnection(async (client) => {
-        const result = await client.query("SELECT table_name, table_schema FROM information_schema.tables WHERE table_schema NOT IN ('information_schema', 'pg_catalog')");
-        return {
-            resources: result.rows.map((row) => ({
-                uri: `postgres://${row.table_schema}/${row.table_name}/${SCHEMA_PATH}`,
-                mimeType: "application/json",
-                name: `"${row.table_schema}"."${row.table_name}" database schema`,
-            })),
-        };
-    });
-};
-export const readResourceHandler = async (request) => {
-    const resourceUrl = new URL(request.params.uri);
-    const pathComponents = resourceUrl.pathname.split("/");
-    const schema = pathComponents.pop();
-    const tableName = pathComponents.pop();
-    const schemaName = resourceUrl.hostname;
-    if (schema !== SCHEMA_PATH) {
-        throw new Error("Invalid resource URI");
-    }
-    return await withConnection(async (client) => {
-        const columnsResult = await client.query(`SELECT 
-                column_name, 
-                data_type, 
-                is_nullable, 
-                column_default,
-                character_maximum_length,
-                numeric_precision,
-                numeric_scale 
-             FROM information_schema.columns 
-             WHERE table_name = $1 AND table_schema = $2
-             ORDER BY ordinal_position`, [tableName, schemaName]);
-        const indexesResult = await client.query(`SELECT
-                ix.relname as index_name,
-                i.indisunique as is_unique,
-                a.attname as column_name
-            FROM
-                pg_class t,
-                pg_class ix,
-                pg_index i,
-                pg_attribute a,
-                pg_namespace n
-            WHERE
-                t.oid = i.indrelid
-                AND ix.oid = i.indexrelid
-                AND a.attrelid = t.oid
-                AND a.attnum = ANY(i.indkey)
-                AND t.relkind = 'r'
-                AND t.relname = $1
-                AND n.oid = t.relnamespace
-                AND n.nspname = $2
-            ORDER BY
-                ix.relname`, [tableName, schemaName]);
-        return {
-            contents: [
-                {
-                    uri: request.params.uri,
-                    mimeType: "application/json",
-                    text: JSON.stringify({
-                        columns: columnsResult.rows,
-                        indexes: indexesResult.rows
-                    }, null, 2),
-                },
-            ],
-        };
-    });
-};

package/dist/resources.js

@@ -0,0 +1,73 @@
+import { withConnection, isPoolInitialized } from "./db.js";
+const SCHEMA_PATH = "schema";
+export const listResourcesHandler = async (request) => {
+    if (!isPoolInitialized()) {
+        return { resources: [] };
+    }
+    return await withConnection(async (client) => {
+        const result = await client.query("SELECT table_name, table_schema FROM information_schema.tables WHERE table_schema NOT IN ('information_schema', 'pg_catalog')");
+        return {
+            resources: result.rows.map((row) => ({
+                uri: `postgres://${row.table_schema}/${row.table_name}/${SCHEMA_PATH}`,
+                mimeType: "application/json",
+                name: `"${row.table_schema}"."${row.table_name}" database schema`,
+            })),
+        };
+    });
+};
+export const readResourceHandler = async (request) => {
+    const resourceUrl = new URL(request.params.uri);
+    const pathComponents = resourceUrl.pathname.split("/");
+    const schema = pathComponents.pop();
+    const tableName = pathComponents.pop();
+    const schemaName = resourceUrl.hostname;
+    if (schema !== SCHEMA_PATH) {
+        throw new Error("Invalid resource URI");
+    }
+    return await withConnection(async (client) => {
+        const columnsResult = await client.query(`SELECT 
+                column_name, 
+                data_type, 
+                is_nullable, 
+                column_default,
+                character_maximum_length,
+                numeric_precision,
+                numeric_scale 
+             FROM information_schema.columns 
+             WHERE table_name = $1 AND table_schema = $2
+             ORDER BY ordinal_position`, [tableName, schemaName]);
+        const indexesResult = await client.query(`SELECT
+                ix.relname as index_name,
+                i.indisunique as is_unique,
+                a.attname as column_name
+            FROM
+                pg_class t,
+                pg_class ix,
+                pg_index i,
+                pg_attribute a,
+                pg_namespace n
+            WHERE
+                t.oid = i.indrelid
+                AND ix.oid = i.indexrelid
+                AND a.attrelid = t.oid
+                AND a.attnum = ANY(i.indkey)
+                AND t.relkind = 'r'
+                AND t.relname = $1
+                AND n.oid = t.relnamespace
+                AND n.nspname = $2
+            ORDER BY
+                ix.relname`, [tableName, schemaName]);
+        return {
+            contents: [
+                {
+                    uri: request.params.uri,
+                    mimeType: "application/json",
+                    text: JSON.stringify({
+                        columns: columnsResult.rows,
+                        indexes: indexesResult.rows
+                    }, null, 2),
+                },
+            ],
+        };
+    });
+};

package/dist/server.js

@@ -1,19 +1,13 @@
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { CallToolRequestSchema, ListResourcesRequestSchema, ListResourceTemplatesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 import { z } from "zod";
 import { initializePool } from "./db.js";
 import { listResourcesHandler, readResourceHandler, callToolHandler } from "./handlers.js";
 import { tools } from "./tools.js";
-const server = new Server({
+// Create server instance
+const server = new McpServer({
     name: "postgres-server",
-    version: "1.0.6",
-}, {
-    capabilities: {
-        resources: {},
-        tools: {},
-        prompts: {}, // Add this line to indicate support for prompts
-    },
+    version: "1.0.8",
 });
 const prompts = [
     { name: "pg-query: Execute Query", description: "pg-query select * from test" },
@@ -22,30 +16,58 @@ const prompts = [
     { name: "pg-connect: Database Connection", description: "pg-connect to PostgreSQL using a connection string like host.docker.internal:5432/dbname with user name and password" },
     { name: "pg-awr: Performance Report", description: "pg-awr to generate a PostgreSQL performance report (requires pg_stat_statements extension)" }
 ];
-const PromptsListRequestSchema = z.object({
-    method: z.literal("prompts/list"),
-    params: z.object({}),
+// Register Prompts
+server.registerPrompt("postgres-prompts", {
+    description: "List available Postgres prompts"
+}, async () => ({
+    messages: [
+        {
+            role: "assistant",
+            content: {
+                type: "text",
+                text: "Available Postgres prompts:\n" + prompts.map(p => `- ${p.name}: ${p.description}`).join("\n")
+            }
+        }
+    ]
+}));
+// Register Resource Templates
+const resourceTemplate = new ResourceTemplate("postgres://{schema}/{table}/schema", {
+    list: async () => listResourcesHandler({})
 });
-server.setRequestHandler(PromptsListRequestSchema, async () => {
-    return {
-        prompts,
-    };
+server.registerResource("Table Schema", resourceTemplate, { description: "Schema information for a PostgreSQL database table including column names and data types" }, async (uri) => {
+    return readResourceHandler({ params: { uri: uri.toString() } });
 });
-server.setRequestHandler(ListResourceTemplatesRequestSchema, async () => {
-    return {
-        resourceTemplates: [
-            {
-                uriTemplate: "postgres://{schema}/{table_name}/schema",
-                name: "Table Schema",
-                description: "Schema information for a PostgreSQL database table including column names and data types",
-            },
-        ],
-    };
+// Register Tools
+tools.forEach(tool => {
+    // Basic mapping of JSON schema to Zod for simple cases
+    let inputSchema = z.object({});
+    if (tool.inputSchema && tool.inputSchema.properties) {
+        const shape = {};
+        for (const [key, prop] of Object.entries(tool.inputSchema.properties)) {
+            let field = z.any();
+            if (prop.type === "string") {
+                field = z.string();
+            }
+            if (prop.description) {
+                field = field.describe(prop.description);
+            }
+            if (tool.inputSchema.required && !tool.inputSchema.required.includes(key)) {
+                field = field.optional();
+            }
+            else if (!tool.inputSchema.required) {
+                field = field.optional();
+            }
+            shape[key] = field;
+        }
+        inputSchema = z.object(shape);
+    }
+    server.registerTool(tool.name, {
+        description: tool.description,
+        inputSchema: inputSchema
+    }, async (args) => {
+        return callToolHandler({ params: { name: tool.name, arguments: args } });
+    });
 });
-server.setRequestHandler(ListResourcesRequestSchema, listResourcesHandler);
-server.setRequestHandler(ReadResourceRequestSchema, readResourceHandler);
-server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools }));
-server.setRequestHandler(CallToolRequestSchema, callToolHandler);
 export async function runServer() {
     const args = process.argv.slice(2);
     const databaseUrl = args[0];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@marcelo-ochoa/server-postgres",
   "mcpName": "io.github.marcelo-ochoa/postgres",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "repository": {
     "type": "git",
     "url": "https://github.com/marcelo-ochoa/servers.git",