@datanimbus/dnio-mcp 1.0.0

package/src/tools/data-service-registry.js

@@ -0,0 +1,500 @@
+'use strict';
+
+const {z} = require('zod');
+const logger = require('../utils/logger');
+const {
+    definitionToCreateSchema,
+    definitionToUpdateSchema,
+    schemaToDescription
+} = require('../schemas/schema-converter');
+
+/**
+ * DataServiceToolRegistry
+ *
+ * Dynamically registers MCP tools for each DNIO Data Service.
+ * Each service gets 5 tools: list, get, create, update, delete.
+ * Tools are named: {serviceName}_list, {serviceName}_get, etc.
+ *
+ * Supports runtime registration/deregistration as services start/stop.
+ */
+class DataServiceToolRegistry {
+    /**
+     * @param {McpServer} mcpServer   - MCP server instance
+     * @param {DNIOClient} dnioClient - authenticated DNIO API client
+     * @param {string} appName        - DNIO app name (e.g. 'ravi')
+     */
+    constructor(mcpServer, dnioClient, appName) {
+        this.server = mcpServer;
+        this.client = dnioClient;
+        this.appName = appName;
+        /** @type {Map<string, {serviceId: string, servicePath: string, toolHandles: any[]}>} */
+        this.registeredServices = new Map();
+    }
+
+    /**
+     * Fetch all active services and register tools for each.
+     * Call this on server startup.
+     */
+    async registerAllServices() {
+        try {
+            const services = await this.client.services.list(this.appName, {
+                filter: {status: 'Active'},
+                select: 'name,api,_id,attributeCount,status,definition,description'
+            });
+            const serviceList = Array.isArray(services) ? services : [];
+            logger.info(`Found ${serviceList.length} active data services for app '${this.appName}'`);
+
+            for (const svc of serviceList) {
+                await this.registerService(svc);
+            }
+
+            logger.info(`Registered tools for ${this.registeredServices.size} data services`);
+        } catch (error) {
+            logger.error('Failed to register data services', {error: error.message});
+            throw error;
+        }
+    }
+
+    /**
+     * Register MCP tools for a single data service.
+     *
+     * @param {object} serviceConfig - Service object from DNIO API (needs _id, name, api, definition)
+     */
+    async registerService(serviceConfig) {
+        const {_id: serviceId, name, api, definition, description: svcDescription} = serviceConfig;
+        const servicePath = (api || `/${name}`).replace(/^\//, '');
+        const toolPrefix = this._sanitizeToolName(name);
+
+        if (this.registeredServices.has(serviceId)) {
+            logger.warn(`Service '${name}' (${serviceId}) already registered, skipping`);
+            return;
+        }
+
+        // If definition not included in list response, fetch full schema
+        let fullDefinition = definition;
+        if (!fullDefinition || fullDefinition.length === 0) {
+            try {
+                const fullSchema = await this.client.services.getSchema(this.appName, serviceId);
+                fullDefinition = fullSchema.definition || [];
+            } catch (err) {
+                logger.error(`Failed to fetch schema for ${name} (${serviceId})`, {error: err.message});
+                fullDefinition = [];
+            }
+        }
+
+        const schemaDesc = fullDefinition.length > 0
+            ? schemaToDescription(fullDefinition)
+            : 'Schema not available';
+
+        const serviceDesc = svcDescription || `Data service '${name}'`;
+
+        logger.info(`Registering tools for service: ${name} (${serviceId}) -> ${toolPrefix}_*`);
+
+        const toolHandles = [];
+        const client = this.client;
+        const appName = this.appName;
+
+        // ─── 1. LIST records ─────────────────────────────────────────
+        toolHandles.push(
+            this.server.registerTool(
+                `${toolPrefix}_list`,
+                {
+                    title: `List ${name} records`,
+                    description: `List/search records from the '${name}' data service. ${serviceDesc}
+
+Use this to browse, search, and paginate through ${name} records.
+
+Args:
+  - filter (string, optional): MongoDB-style JSON filter string (e.g. '{"active": true}')
+  - sort (string, optional): Sort field with direction (e.g. '-_metadata.createdAt' for newest first)
+  - select (string, optional): Comma-separated fields to include (e.g. 'name,_id,active')
+  - page (number, optional): Page number, starting at 1 (default: 1)
+  - count (number, optional): Records per page, 1-100 (default: 20)
+
+Returns: Array of ${name} records.
+
+Schema fields:
+${schemaDesc}`,
+                    inputSchema: {
+                        filter: z.string().optional().describe('MongoDB-style JSON filter (e.g. \'{"active": true}\')'),
+                        sort: z.string().optional().describe('Sort field, prefix with - for descending (e.g. \'-_metadata.createdAt\')'),
+                        select: z.string().optional().describe('Comma-separated fields to return'),
+                        page: z.number().int().min(1).default(1).optional().describe('Page number (default: 1)'),
+                        count: z.number().int().min(1).max(100).default(20).optional().describe('Records per page (default: 20)')
+                    },
+                    annotations: {
+                        readOnlyHint: true,
+                        destructiveHint: false,
+                        idempotentHint: true,
+                        openWorldHint: false
+                    }
+                },
+                async (params) => {
+                    try {
+                        const filter = params.filter ? JSON.parse(params.filter) : undefined;
+                        const result = await client.records.list(appName, servicePath, {
+                            filter,
+                            sort: params.sort,
+                            select: params.select,
+                            page: params.page || 1,
+                            count: params.count || 20
+                        });
+                        const records = Array.isArray(result) ? result : (result.records || [result]);
+                        return {
+                            content: [{
+                                type: 'text',
+                                text: JSON.stringify({
+                                    service: name,
+                                    count: records.length,
+                                    page: params.page || 1,
+                                    records
+                                }, null, 2)
+                            }]
+                        };
+                    } catch (error) {
+                        return _toolError(`Failed to list ${name} records`, error);
+                    }
+                }
+            )
+        );
+
+        // ─── 2. GET single record ────────────────────────────────────
+        toolHandles.push(
+            this.server.registerTool(
+                `${toolPrefix}_get`,
+                {
+                    title: `Get ${name} record`,
+                    description: `Retrieve a single record from '${name}' by its ID.
+
+Args:
+  - recordId (string, required): The record ID (e.g. '${serviceConfig.definition?.[0]?.prefix || 'REC'}1001')
+  - expand (boolean, optional): Expand related/linked records (default: false)
+
+Returns: Full ${name} record object.
+
+Schema fields:
+${schemaDesc}`,
+                    inputSchema: {
+                        recordId: z.string().min(1).describe(`Record ID of the ${name} record`),
+                        expand: z.boolean().default(false).optional().describe('Expand related records')
+                    },
+                    annotations: {
+                        readOnlyHint: true,
+                        destructiveHint: false,
+                        idempotentHint: true,
+                        openWorldHint: false
+                    }
+                },
+                async (params) => {
+                    try {
+                        const result = await client.records.get(appName, servicePath, params.recordId, {
+                            expand: params.expand
+                        });
+                        return {
+                            content: [{
+                                type: 'text',
+                                text: JSON.stringify({service: name, record: result}, null, 2)
+                            }]
+                        };
+                    } catch (error) {
+                        if (error.status === 404) {
+                            return {
+                                content: [{
+                                    type: 'text',
+                                    text: `Record '${params.recordId}' not found in ${name}`
+                                }]
+                            };
+                        }
+                        return _toolError(`Failed to get ${name} record`, error);
+                    }
+                }
+            )
+        );
+
+        // ─── 3. CREATE record ────────────────────────────────────────
+        const createSchema = fullDefinition.length > 0
+            ? definitionToCreateSchema(fullDefinition)
+            : z.record(z.any());
+
+        toolHandles.push(
+            this.server.registerTool(
+                `${toolPrefix}_create`,
+                {
+                    title: `Create ${name} record`,
+                    description: `Create a new record in the '${name}' data service.
+
+Provide the record data as a JSON object. The _id is auto-generated.
+
+Schema fields:
+${schemaDesc}
+
+Args:
+  - data (object, required): The record data matching the schema above
+
+Returns: The created record with its generated _id.`,
+                    inputSchema: {
+                        data: z.record(z.any()).describe(`Record data for ${name}. Refer to schema fields in the description.`)
+                    },
+                    annotations: {
+                        readOnlyHint: false,
+                        destructiveHint: false,
+                        idempotentHint: false,
+                        openWorldHint: false
+                    }
+                },
+                async (params) => {
+                    try {
+                        const result = await client.records.create(appName, servicePath, params.data);
+                        return {
+                            content: [{
+                                type: 'text',
+                                text: JSON.stringify({
+                                    service: name,
+                                    action: 'created',
+                                    record: result
+                                }, null, 2)
+                            }]
+                        };
+                    } catch (error) {
+                        return _toolError(`Failed to create ${name} record`, error);
+                    }
+                }
+            )
+        );
+
+        // ─── 4. UPDATE record ────────────────────────────────────────
+        toolHandles.push(
+            this.server.registerTool(
+                `${toolPrefix}_update`,
+                {
+                    title: `Update ${name} record`,
+                    description: `Update an existing record in the '${name}' data service.
+
+Provide the record ID and the fields to update.
+
+Schema fields:
+${schemaDesc}
+
+Args:
+  - recordId (string, required): The record ID to update
+  - data (object, required): Fields to update (partial update supported)
+
+Returns: The updated record.`,
+                    inputSchema: {
+                        recordId: z.string().min(1).describe(`Record ID of the ${name} record to update`),
+                        data: z.record(z.any()).describe(`Fields to update for ${name}. Refer to schema fields in the description.`)
+                    },
+                    annotations: {
+                        readOnlyHint: false,
+                        destructiveHint: false,
+                        idempotentHint: true,
+                        openWorldHint: false
+                    }
+                },
+                async (params) => {
+                    try {
+                        const result = await client.records.update(appName, servicePath, params.recordId, params.data);
+                        return {
+                            content: [{
+                                type: 'text',
+                                text: JSON.stringify({
+                                    service: name,
+                                    action: 'updated',
+                                    recordId: params.recordId,
+                                    record: result
+                                }, null, 2)
+                            }]
+                        };
+                    } catch (error) {
+                        if (error.status === 404) {
+                            return {
+                                content: [{
+                                    type: 'text',
+                                    text: `Record '${params.recordId}' not found in ${name}`
+                                }]
+                            };
+                        }
+                        return _toolError(`Failed to update ${name} record`, error);
+                    }
+                }
+            )
+        );
+
+        // ─── 5. DELETE record ────────────────────────────────────────
+        toolHandles.push(
+            this.server.registerTool(
+                `${toolPrefix}_delete`,
+                {
+                    title: `Delete ${name} record`,
+                    description: `Delete
+                    a record from the '${name}' data service.
+
+                    ⚠️ This is a destructive operation and cannot be undone.
+
+Args:
+  - recordId (string, required): The record ID to delete
+
+                    Returns: Confirmation of deletion.`,
+                    inputSchema: {
+                        recordId: z.string().min(1).describe(`Record ID of the ${name} record to delete`)
+                    },
+                    annotations: {
+                        readOnlyHint: false,
+                        destructiveHint: true,
+                        idempotentHint: false,
+                        openWorldHint: false
+                    }
+                },
+                async (params) => {
+                    try {
+                        const result = await client.records.delete(appName, servicePath, params.recordId);
+                        return {
+                            content: [{
+                                type: 'text',
+                                text: JSON.stringify({
+                                    service: name,
+                                    action: 'deleted',
+                                    recordId: params.recordId,
+                                    result
+                                }, null, 2)
+                            }]
+                        };
+                    } catch (error) {
+                        if (error.status === 404) {
+                            return {
+                                content: [{
+                                    type: 'text',
+                                    text: `Record '${params.recordId}' not found in ${name}`
+                                }]
+                            };
+                        }
+                        return _toolError(`Failed to delete ${name} record`, error);
+                    }
+                }
+            )
+        );
+
+        // ─── 6. COUNT records ────────────────────────────────────────
+        toolHandles.push(
+            this.server.registerTool(
+                `${toolPrefix}_count`,
+                {
+                    title: `Count ${name} records`,
+                    description: `Count the total number of records in the '${name}' data service, with optional filtering.
+
+Args:
+  - filter (string, optional): MongoDB-style JSON filter string (e.g. '{"active": true}')
+
+Returns: The total count of matching records.`,
+                    inputSchema: {
+                        filter: z.string().optional().describe('MongoDB-style JSON filter (e.g. \'{"active": true}\')')
+                    },
+                    annotations: {
+                        readOnlyHint: true,
+                        destructiveHint: false,
+                        idempotentHint: true,
+                        openWorldHint: false
+                    }
+                },
+                async (params) => {
+                    try {
+                        const filter = params.filter ? JSON.parse(params.filter) : undefined;
+                        const result = await client.records.count(appName, servicePath, filter);
+                        return {
+                            content: [{
+                                type: 'text',
+                                text: JSON.stringify({service: name, count: result}, null, 2)
+                            }]
+                        };
+                    } catch (error) {
+                        return _toolError(`Failed to count ${name} records`, error);
+                    }
+                }
+            )
+        );
+
+        this.registeredServices.set(serviceId, {
+            serviceId,
+            name,
+            servicePath,
+            toolPrefix,
+            toolHandles,
+            toolCount: toolHandles.length
+        });
+
+        logger.info(`Registered ${toolHandles.length} tools for '${name}': ${toolPrefix}_[list|get|create|update|delete|count]`);
+    }
+
+    /**
+     * Deregister tools for a service (e.g. when service is stopped/deleted).
+     * Uses the MCP tool handle's .remove() method to cleanly deregister.
+     *
+     * @param {string} serviceId - DNIO service ID (e.g. 'SRVC3683')
+     */
+    async deregisterService(serviceId) {
+        const entry = this.registeredServices.get(serviceId);
+        if (!entry) return;
+
+        for (const handle of entry.toolHandles) {
+            if (handle && typeof handle.remove === 'function') {
+                handle.remove();
+            }
+        }
+
+        logger.info(`Deregistered tools for service '${entry.name}' (${serviceId})`);
+        this.registeredServices.delete(serviceId);
+    }
+
+    /**
+     * Re-register a service (e.g. after schema change).
+     */
+    async refreshService(serviceId) {
+        await this.deregisterService(serviceId);
+        const schema = await this.client.services.getSchema(this.appName, serviceId);
+        await this.registerService(schema);
+    }
+
+    /**
+     * Get summary of all registered services and their tools.
+     */
+    getSummary() {
+        const services = [];
+        for (const [id, entry] of this.registeredServices) {
+            services.push({
+                serviceId: id,
+                name: entry.name,
+                path: entry.servicePath,
+                toolPrefix: entry.toolPrefix,
+                toolCount: entry.toolCount
+            });
+        }
+        return services;
+    }
+
+    /**
+     * Sanitize a service name into a valid MCP tool name prefix.
+     * MCP tool names must be snake_case, lowercase.
+     */
+    _sanitizeToolName(name) {
+        return name
+            .toLowerCase()
+            .replace(/[^a-z0-9]+/g, '_')
+            .replace(/^_|_$/g, '');
+    }
+}
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+function _toolError(message, error) {
+    const detail = error.body?.message || error.message || 'Unknown error';
+    logger.error(message, {error: detail, status: error.status});
+    return {
+        content: [{
+            type: 'text',
+            text: `Error: ${message}. ${detail}`
+        }],
+        isError: true
+    };
+}
+
+module.exports = DataServiceToolRegistry;