mcp-server-blk/dist/services/schemaService.js

MCP server for managing blocks schemas via API

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.createSchema = createSchema;
exports.updateSchema = updateSchema;
const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
const logger_1 = require("../utils/logger");
const authService_1 = __importDefault(require("./authService"));
const baseUrl = `${process.env.API_BASE_URL}/graphql/v1`;
async function createOperation(args) {
    const method = 'POST';
    validateFields(args.Fields);
    const url = `${baseUrl}/schemas/define`;
    const bearerToken = await (0, authService_1.default)();
    const responseData = await sendRequest(url, method, bearerToken, args);
    const result = {
        content: [
            {
                type: 'text',
                text: `✅ Schema "${args.SchemaName}" created successfully!\n\nResponse: ${JSON.stringify(responseData, null, 2)}`,
            },
        ],
    };
    return result;
}
async function updateOperation(args) {
    const method = 'PUT';
    validateFields(args.Fields);
    const url = `${baseUrl}/schemas/define`;
    const bearerToken = await (0, authService_1.default)();
    const responseData = await sendRequest(url, method, bearerToken, args);
    const result = {
        content: [
            {
                type: 'text',
                text: `✅ Schema "${args.SchemaName}" updated successfully!\n\nResponse: ${JSON.stringify(responseData, null, 2)}`,
            },
        ],
    };
    return result;
}
function getMissingFields(args) {
    const missingFields = [];
    if (!args.CollectionName)
        missingFields.push('CollectionName');
    if (!args.SchemaName)
        missingFields.push('SchemaName');
    if (!args.Fields || !Array.isArray(args.Fields))
        missingFields.push('Fields');
    if (!args.ProjectKey)
        missingFields.push('ProjectKey');
    return missingFields;
}
function validateFields(fields) {
    for (const field of fields) {
        if (!field.Name || !field.Type) {
            (0, logger_1.debugLog)('error', 'Invalid field structure', { field });
            throw new types_js_1.McpError(types_js_1.ErrorCode.InvalidParams, 'Each field must have Name and Type properties');
        }
    }
}
async function sendRequest(url, method, bearerToken, payload) {
    const blocksKey = process.env.BLOCKS_KEY || '';
    const headers = {
        'Content-Type': 'application/json',
        'x-blocks-key': blocksKey,
        'Authorization': `Bearer ${bearerToken}`,
    };
    (0, logger_1.debugLog)('info', 'Making API request', { url, method, headers: { ...headers, Authorization: 'Bearer [HIDDEN]' }, payload });
    const response = await fetch(url, { method, headers, body: JSON.stringify(payload) });
    (0, logger_1.debugLog)('info', `📥 API response received`, {
        status: response.status,
        statusText: response.statusText,
        headers: Object.fromEntries(response.headers.entries()),
        response: { response }
    });
    const responseText = await response.text();
    let responseData;
    try {
        responseData = JSON.parse(responseText);
        (0, logger_1.debugLog)('info', `✅ Successfully parsed JSON response from API`, { responseText });
    }
    catch (parseError) {
        const errorMessage = parseError instanceof Error ? parseError.message : 'Unknown parse error';
        (0, logger_1.debugLog)('warn', `⚠️ Could not parse API response as JSON`, {
            parseError: errorMessage,
            responseText
        });
        responseData = responseText;
    }
    return responseData;
}
async function createSchema(args) {
    const missingFields = getMissingFields(args);
    if (missingFields.length > 0) {
        (0, logger_1.debugLog)('error', `Missing required fields for create_operation`, { missingFields });
        throw new types_js_1.McpError(types_js_1.ErrorCode.InvalidParams, `Missing required parameters: ${missingFields.join(', ')}`);
    }
    const createSchemaArgs = {
        CollectionName: args.CollectionName,
        SchemaName: args.SchemaName,
        Fields: args.Fields,
        ProjectKey: args.ProjectKey,
        SchemaType: args.SchemaType || 1
    };
    return createOperation(createSchemaArgs);
}
async function updateSchema(args) {
    const missingFields = getMissingFields(args);
    if (!args.ItemId)
        missingFields.push('ItemId');
    if (missingFields.length > 0) {
        (0, logger_1.debugLog)('error', `Missing required fields for update_operation`, { missingFields });
        throw new types_js_1.McpError(types_js_1.ErrorCode.InvalidParams, `Missing required parameters: ${missingFields.join(', ')}`);
    }
    const updateSchemaArgs = {
        CollectionName: args.CollectionName,
        SchemaName: args.SchemaName,
        Fields: args.Fields,
        ProjectKey: args.ProjectKey,
        SchemaType: args.SchemaType || 1,
        ItemId: args.ItemId
    };
    return updateOperation(updateSchemaArgs);
}
//# sourceMappingURL=schemaService.js.map