@softtechai/quickmcp 1.0.8

package/dist/web/generators/MCPServerGenerator-new.js

@@ -0,0 +1,284 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MCPServerGenerator = void 0;
+const sqlite_manager_js_1 = require("../database/sqlite-manager.js");
+class MCPServerGenerator {
+    constructor() {
+        this.sqliteManager = new sqlite_manager_js_1.SQLiteManager();
+    }
+    async generateServer(serverId, serverName, parsedData, dbConfig) {
+        try {
+            console.error(`🚀 Generating virtual MCP server: ${serverId}`);
+            // Create server config
+            const serverConfig = {
+                id: serverId,
+                name: serverName,
+                dbConfig: dbConfig,
+                createdAt: new Date().toISOString()
+            };
+            // Save server to SQLite database only
+            this.sqliteManager.saveServer(serverConfig);
+            console.error(`✅ Server config saved to SQLite database: ${serverId}`);
+            // Generate and save tools
+            const tools = this.generateToolsForData(serverId, parsedData, dbConfig);
+            if (tools.length > 0) {
+                this.sqliteManager.saveTools(tools);
+                console.error(`✅ Generated ${tools.length} tools for server ${serverId}`);
+            }
+            // Generate and save resources
+            const resources = this.generateResourcesForData(serverId, parsedData, dbConfig);
+            if (resources.length > 0) {
+                this.sqliteManager.saveResources(resources);
+                console.error(`✅ Generated ${resources.length} resources for server ${serverId}`);
+            }
+            return {
+                success: true,
+                message: `Virtual MCP server '${serverId}' created successfully with ${tools.length} tools and ${resources.length} resources`
+            };
+        }
+        catch (error) {
+            console.error(`❌ Error generating server ${serverId}:`, error);
+            return {
+                success: false,
+                message: `Failed to generate server: ${error instanceof Error ? error.message : 'Unknown error'}`
+            };
+        }
+    }
+    generateToolsForData(serverId, parsedData, dbConfig) {
+        const tools = [];
+        for (const [tableName, rows] of Object.entries(parsedData)) {
+            if (!rows || rows.length === 0)
+                continue;
+            const columns = this.analyzeColumns(rows);
+            const cleanTableName = this.sanitizeName(tableName);
+            // GET tool
+            tools.push({
+                server_id: serverId,
+                name: `get_${cleanTableName}`,
+                description: `Get records from ${tableName} table`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        limit: {
+                            type: 'number',
+                            description: 'Maximum number of records to return',
+                            default: 100,
+                            minimum: 1,
+                            maximum: 1000
+                        },
+                        offset: {
+                            type: 'number',
+                            description: 'Number of records to skip',
+                            default: 0,
+                            minimum: 0
+                        },
+                        ...this.generateFilterProperties(columns)
+                    },
+                    required: []
+                },
+                sqlQuery: this.generateSelectQuery(tableName, columns, dbConfig.type),
+                operation: 'SELECT'
+            });
+            // CREATE tool
+            tools.push({
+                server_id: serverId,
+                name: `create_${cleanTableName}`,
+                description: `Create a new record in ${tableName} table`,
+                inputSchema: {
+                    type: 'object',
+                    properties: this.generateInputProperties(columns, true),
+                    required: columns.filter(col => !col.nullable && col.name.toLowerCase() !== 'id').map(col => col.name)
+                },
+                sqlQuery: this.generateInsertQuery(tableName, columns, dbConfig.type),
+                operation: 'INSERT'
+            });
+            // UPDATE tool
+            if (columns.some(col => col.name.toLowerCase() === 'id')) {
+                tools.push({
+                    server_id: serverId,
+                    name: `update_${cleanTableName}`,
+                    description: `Update a record in ${tableName} table`,
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            id: {
+                                type: ['string', 'number'],
+                                description: 'ID of the record to update'
+                            },
+                            ...this.generateInputProperties(columns, false)
+                        },
+                        required: ['id']
+                    },
+                    sqlQuery: this.generateUpdateQuery(tableName, columns, dbConfig.type),
+                    operation: 'UPDATE'
+                });
+                // DELETE tool
+                tools.push({
+                    server_id: serverId,
+                    name: `delete_${cleanTableName}`,
+                    description: `Delete a record from ${tableName} table`,
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            id: {
+                                type: ['string', 'number'],
+                                description: 'ID of the record to delete'
+                            }
+                        },
+                        required: ['id']
+                    },
+                    sqlQuery: this.generateDeleteQuery(tableName, dbConfig.type),
+                    operation: 'DELETE'
+                });
+            }
+        }
+        return tools;
+    }
+    generateResourcesForData(serverId, parsedData, dbConfig) {
+        const resources = [];
+        for (const [tableName, rows] of Object.entries(parsedData)) {
+            if (!rows || rows.length === 0)
+                continue;
+            const cleanTableName = this.sanitizeName(tableName);
+            resources.push({
+                server_id: serverId,
+                name: `${cleanTableName}_list`,
+                description: `List all records from ${tableName} table`,
+                uri_template: `${cleanTableName}://list`,
+                sqlQuery: this.generateSelectQuery(tableName, this.analyzeColumns(rows), dbConfig.type, false)
+            });
+        }
+        return resources;
+    }
+    analyzeColumns(rows) {
+        if (!rows || rows.length === 0)
+            return [];
+        const firstRow = rows[0];
+        const columns = [];
+        for (const [key, value] of Object.entries(firstRow)) {
+            let type = 'string';
+            if (typeof value === 'number') {
+                type = Number.isInteger(value) ? 'integer' : 'number';
+            }
+            else if (typeof value === 'boolean') {
+                type = 'boolean';
+            }
+            else if (value instanceof Date) {
+                type = 'string'; // Dates are handled as strings in JSON
+            }
+            else if (value === null || value === undefined) {
+                // Check other rows to determine type
+                for (let i = 1; i < Math.min(rows.length, 10); i++) {
+                    const otherValue = rows[i][key];
+                    if (otherValue !== null && otherValue !== undefined) {
+                        if (typeof otherValue === 'number') {
+                            type = Number.isInteger(otherValue) ? 'integer' : 'number';
+                        }
+                        else if (typeof otherValue === 'boolean') {
+                            type = 'boolean';
+                        }
+                        break;
+                    }
+                }
+            }
+            columns.push({
+                name: key,
+                type: type,
+                nullable: rows.some(row => row[key] === null || row[key] === undefined)
+            });
+        }
+        return columns;
+    }
+    generateFilterProperties(columns) {
+        const properties = {};
+        for (const column of columns) {
+            const baseType = column.type === 'integer' ? 'number' : column.type;
+            properties[`filter_${column.name}`] = {
+                type: baseType,
+                description: `Filter by ${column.name}`
+            };
+        }
+        return properties;
+    }
+    generateInputProperties(columns, isCreate) {
+        const properties = {};
+        for (const column of columns) {
+            // Skip ID field for create operations
+            if (isCreate && column.name.toLowerCase() === 'id')
+                continue;
+            const baseType = column.type === 'integer' ? 'number' : column.type;
+            properties[column.name] = {
+                type: column.nullable ? [baseType, 'null'] : baseType,
+                description: `${column.name} field`
+            };
+        }
+        return properties;
+    }
+    generateSelectQuery(tableName, columns, dbType, withParams = true) {
+        const columnList = columns.map(col => `[${col.name}]`).join(', ');
+        let query = `SELECT ${columnList} FROM [${tableName}]`;
+        if (withParams) {
+            const whereConditions = columns.map(col => `(@filter_${col.name} IS NULL OR [${col.name}] = @filter_${col.name})`).join(' AND ');
+            query += ` WHERE ${whereConditions}`;
+            if (dbType === 'mssql') {
+                // Use TOP for SQL Server to avoid OFFSET/FETCH complexity
+                // Replace SELECT with SELECT TOP
+                query = query.replace('SELECT ', 'SELECT TOP (@limit) ');
+            }
+            else {
+                query += ' LIMIT @limit OFFSET @offset';
+            }
+        }
+        return query;
+    }
+    generateInsertQuery(tableName, columns, dbType) {
+        const insertColumns = columns.filter(col => col.name.toLowerCase() !== 'id');
+        const columnNames = insertColumns.map(col => `[${col.name}]`).join(', ');
+        const paramNames = insertColumns.map(col => `@${col.name}`).join(', ');
+        return `INSERT INTO [${tableName}] (${columnNames}) VALUES (${paramNames})`;
+    }
+    generateUpdateQuery(tableName, columns, dbType) {
+        const updateColumns = columns.filter(col => col.name.toLowerCase() !== 'id');
+        const setClause = updateColumns.map(col => `[${col.name}] = @${col.name}`).join(', ');
+        return `UPDATE [${tableName}] SET ${setClause} WHERE [Id] = @id`;
+    }
+    generateDeleteQuery(tableName, dbType) {
+        return `DELETE FROM [${tableName}] WHERE [Id] = @id`;
+    }
+    sanitizeName(name) {
+        return name.toLowerCase()
+            .replace(/[^a-z0-9]/g, '_')
+            .replace(/_{2,}/g, '_')
+            .replace(/^_|_$/g, '');
+    }
+    // Public methods for management
+    getAllServers() {
+        return this.sqliteManager.getAllServers();
+    }
+    getServer(serverId) {
+        return this.sqliteManager.getServer(serverId);
+    }
+    deleteServer(serverId) {
+        this.sqliteManager.deleteServer(serverId);
+        console.error(`🗑️ Deleted server from SQLite database: ${serverId}`);
+    }
+    getAllTools() {
+        return this.sqliteManager.getAllTools();
+    }
+    getToolsForServer(serverId) {
+        return this.sqliteManager.getToolsForServer(serverId);
+    }
+    getAllResources() {
+        return this.sqliteManager.getAllResources();
+    }
+    getResourcesForServer(serverId) {
+        return this.sqliteManager.getResourcesForServer(serverId);
+    }
+    getStats() {
+        return this.sqliteManager.getStats();
+    }
+    close() {
+        this.sqliteManager.close();
+    }
+}
+exports.MCPServerGenerator = MCPServerGenerator;