@seliseblocks/mcp-server/dist/services/schemaService.js

A Model Context Protocol (MCP) server for managing schemas in SELISE Blocks platform, built with TypeScript.

import { ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';
import generateToken from './authService.js';
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 generateToken();
    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)}`,
            },
        ],
    };
    if (responseData.isSuccess && responseData.data?.acknowledged) {
        let reloaded = await reloadSchema(bearerToken).catch((error) => {
        });
        if (reloaded) {
            result.content.push(reloaded.content[0]);
        }
    }
    return result;
}
async function updateOperation(args) {
    const method = 'PUT';
    validateFields(args.Fields);
    const url = `${baseUrl}/schemas/define`;
    const bearerToken = await generateToken();
    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)}`,
            },
        ],
    };
    if (responseData.isSuccess && responseData.data?.acknowledged) {
        let reloaded = await reloadSchema(bearerToken).catch((error) => {
        });
        if (reloaded) {
            result.content.push(reloaded.content[0]);
        }
    }
    return result;
}
async function reloadSchema(bearerToken) {
    const method = 'POST';
    const url = `${baseUrl}/operations/schemas/reload`;
    const responseData = await sendRequest(url, method, bearerToken, {});
    let result;
    if (responseData.isSuccess) {
        result = {
            content: [
                {
                    type: 'text',
                    text: `✅ Schema reloaded successfully!\n\nResponse: ${JSON.stringify(responseData, null, 2)}`,
                },
            ],
        };
    }
    else {
        result = {
            content: [
                {
                    type: 'text',
                    text: `❌ Schema reload failed!\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) {
            throw new McpError(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}`,
    };
    const response = await fetch(url, { method, headers, body: JSON.stringify(payload) });
    const responseText = await response.text();
    let responseData;
    try {
        responseData = JSON.parse(responseText);
    }
    catch (parseError) {
        const errorMessage = parseError instanceof Error ? parseError.message : 'Unknown parse error';
        throw new Error('Invalid JSON response from token endpoint');
    }
    return responseData;
}
async function createSchema(args) {
    const missingFields = getMissingFields(args);
    if (missingFields.length > 0) {
        throw new McpError(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) {
        throw new McpError(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);
}
export { createSchema, updateSchema };
//# sourceMappingURL=schemaService.js.map