@payware/mcp-server 1.0.0

package/src/proxy-server.js

@@ -0,0 +1,205 @@
+#!/usr/bin/env node
+
+/**
+ * HTTP Proxy Server for payware MCP
+ * Provides HTTP/REST interface to the MCP server for external access
+ */
+
+import express from 'express';
+import cors from 'cors';
+import { spawn } from 'child_process';
+import './config/env.js'; // Load environment variables
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+class PaywareMCPProxy {
+  constructor(port = 3001) {
+    this.app = express();
+    this.port = port;
+    this.mcpProcess = null;
+    this.setupMiddleware();
+    this.setupRoutes();
+  }
+
+  setupMiddleware() {
+    // Enable CORS for all routes
+    this.app.use(cors({
+      origin: true,
+      credentials: true
+    }));
+    
+    // Parse JSON requests
+    this.app.use(express.json());
+    
+    // Add request logging
+    this.app.use((req, res, next) => {
+      console.log(`[${new Date().toISOString()}] ${req.method} ${req.path}`);
+      next();
+    });
+  }
+
+  setupRoutes() {
+    // Health check endpoint
+    this.app.get('/health', (req, res) => {
+      res.json({
+        status: 'healthy',
+        timestamp: new Date().toISOString(),
+        service: 'payware-mcp-proxy',
+        version: '1.0.0'
+      });
+    });
+
+    // List available tools
+    this.app.get('/tools', async (req, res) => {
+      try {
+        const result = await this.callMCPTool('tools/list', {});
+        res.json(result);
+      } catch (error) {
+        res.status(500).json({
+          error: 'Failed to list tools',
+          message: error.message
+        });
+      }
+    });
+
+    // Call a specific tool
+    this.app.post('/tools/:toolName', async (req, res) => {
+      try {
+        const { toolName } = req.params;
+        const args = req.body || {};
+
+        const result = await this.callMCPTool('tools/call', {
+          name: toolName,
+          arguments: args
+        });
+
+        res.json(result);
+      } catch (error) {
+        res.status(500).json({
+          error: `Failed to call tool ${req.params.toolName}`,
+          message: error.message
+        });
+      }
+    });
+
+    // Generic MCP endpoint
+    this.app.post('/mcp', async (req, res) => {
+      try {
+        const { method, params } = req.body;
+        const result = await this.callMCPTool(method, params);
+        res.json(result);
+      } catch (error) {
+        res.status(500).json({
+          error: 'MCP call failed',
+          message: error.message
+        });
+      }
+    });
+
+    // Serve API documentation
+    this.app.get('/', (req, res) => {
+      res.json({
+        name: 'payware MCP Proxy',
+        version: '1.0.0',
+        endpoints: {
+          'GET /health': 'Health check',
+          'GET /tools': 'List available MCP tools',
+          'POST /tools/:toolName': 'Call a specific tool',
+          'POST /mcp': 'Generic MCP method call'
+        },
+        examples: {
+          listTools: 'GET /tools',
+          generateKeys: 'POST /tools/generate_rsa_keys',
+          createJWT: 'POST /tools/create_jwt_token'
+        }
+      });
+    });
+  }
+
+  async callMCPTool(method, params = {}) {
+    return new Promise((resolve, reject) => {
+      const mcpServerPath = join(__dirname, 'index.js');
+      const mcpProcess = spawn('node', [mcpServerPath], {
+        stdio: ['pipe', 'pipe', 'pipe'],
+        env: process.env // Pass environment variables to spawned process
+      });
+
+      let responseData = '';
+      let errorData = '';
+
+      const request = {
+        jsonrpc: '2.0',
+        id: Date.now(),
+        method,
+        params
+      };
+
+      mcpProcess.stdout.on('data', (data) => {
+        responseData += data.toString();
+      });
+
+      mcpProcess.stderr.on('data', (data) => {
+        errorData += data.toString();
+      });
+
+      mcpProcess.on('close', (code) => {
+        if (code === 0) {
+          try {
+            // Parse the last valid JSON response
+            const lines = responseData.trim().split('\n');
+            const lastLine = lines[lines.length - 1];
+            const result = JSON.parse(lastLine);
+            resolve(result);
+          } catch (parseError) {
+            reject(new Error(`Failed to parse MCP response: ${parseError.message}`));
+          }
+        } else {
+          reject(new Error(`MCP process failed with code ${code}: ${errorData}`));
+        }
+      });
+
+      // Send the request to the MCP server
+      mcpProcess.stdin.write(JSON.stringify(request) + '\n');
+      mcpProcess.stdin.end();
+    });
+  }
+
+  async start() {
+    this.app.listen(this.port, '0.0.0.0', () => {
+      console.log(`🚀 payware MCP Proxy Server running on http://0.0.0.0:${this.port}`);
+      console.log(`📚 API Documentation: http://localhost:${this.port}`);
+      console.log(`🔧 Health Check: http://localhost:${this.port}/health`);
+      console.log(`🛠️  Tools List: http://localhost:${this.port}/tools`);
+    });
+  }
+
+  async stop() {
+    if (this.mcpProcess) {
+      this.mcpProcess.kill();
+    }
+  }
+}
+
+// Handle graceful shutdown
+process.on('SIGINT', async () => {
+  console.log('\n🛑 Shutting down proxy server...');
+  process.exit(0);
+});
+
+process.on('SIGTERM', async () => {
+  console.log('\n🛑 Shutting down proxy server...');
+  process.exit(0);
+});
+
+// Start the proxy server
+const port = process.env.PROXY_PORT || 3001;
+const proxy = new PaywareMCPProxy(port);
+proxy.start().catch(error => {
+  console.error('❌ Failed to start proxy server:', error);
+  process.exit(1);
+});
+
+export default PaywareMCPProxy;

package/src/shared/data/data-api.js

@@ -0,0 +1,372 @@
+import axios from 'axios';
+import { createJWTToken } from '../../core/auth/jwt-token.js';
+import { createJWTForPartner } from '../../core/auth/jwt-factory.js';
+import { createMinimizedJSON } from '../../core/utils/json-serializer.js';
+import { getSandboxUrl, getProductionUrl, getPartnerIdSafe, getPrivateKeySafe } from '../../config/env.js';
+
+/**
+ * Available report types from the Data API documentation
+ */
+export const REPORT_TYPES = {
+  // Standard reports
+  CURRENT_WEEK_TRANSACTIONS: '/processedTransactionsWTD',
+  CURRENT_MONTH_TRANSACTIONS: '/processedTransactionsMTD',
+  CURRENT_YEAR_TRANSACTIONS: '/processedTransactionsYTD',
+  PRODUCTS_LIST: '/productsList',
+  SHOPS_LIST: '/shopsList',
+  SALES_PER_PRODUCT: '/salesPerProduct',
+  PAYMENT_PROFILES: '/paymentProfiles',
+  TRANSACTIONS_PER_WEBPOS: '/transactionsPerWebPOS',
+  PARTNER_PROFILE: '/partnerProfile',
+
+  // Premium reports
+  PROCESSED_TRANSACTIONS: '/processedTransactions',
+  SCHEDULES_LIST: '/schedulesList',
+  TRANSACTIONS_PER_PRODUCT: '/processedTransactionsPerProduct'
+};
+
+/**
+ * Supported export formats
+ */
+export const EXPORT_FORMATS = {
+  PDF: 'pdf',
+  CSV: 'csv',
+  EXCEL: 'xlsx',
+  JSON: 'json'
+};
+
+/**
+ * Supported locales
+ */
+export const LOCALES = {
+  ENGLISH_US: 'en_US',
+  SPANISH: 'es_ES',
+  BULGARIAN: 'bg_BG'
+};
+
+/**
+ * Create authentication headers based on partner type
+ * @param {string} partnerType - merchant, isv, or payment_institution
+ * @param {Object} authParams - Authentication parameters
+ * @returns {Object} Headers for API request
+ */
+async function createAuthHeaders(partnerType, authParams) {
+  const baseHeaders = {
+    'Content-Type': 'application/json',
+    'Api-Version': '1'
+  };
+
+  let tokenData;
+
+  switch (partnerType) {
+    case 'merchant':
+    case 'payment_institution':
+      // Standard JWT authentication
+      tokenData = createJWTToken(
+        authParams.partnerId,
+        authParams.privateKey,
+        authParams.requestBody
+      );
+      break;
+
+    case 'isv':
+      // ISV JWT with OAuth2 - note the parameter mapping
+      tokenData = await createJWTForPartner({
+        partnerId: authParams.isvPartnerId,
+        privateKey: authParams.privateKey,
+        merchantId: authParams.merchantPartnerId,  // Map merchantPartnerId to merchantId
+        oauth2Token: authParams.oauth2Token,
+        requestBody: authParams.requestBody
+      });
+      break;
+
+    default:
+      throw new Error(`Unknown partner type: ${partnerType}`);
+  }
+
+  return {
+    ...baseHeaders,
+    'Authorization': `Bearer ${tokenData.token}`
+  };
+}
+
+/**
+ * Generate a report asynchronously
+ */
+export async function generateReport({
+  reportUnitId,
+  ignorePagination = false,
+  locale = LOCALES.ENGLISH_US,
+  dateFrom,
+  dateTo,
+  timeZone = 'GMT',
+  partnerType,
+  ...authParams
+}) {
+  if (!reportUnitId) {
+    throw new Error('reportUnitId is required (e.g., "/processedTransactions")');
+  }
+
+  if (!Object.values(REPORT_TYPES).includes(reportUnitId)) {
+    console.warn(`Warning: reportUnitId "${reportUnitId}" is not in the known report types list`);
+  }
+
+  if (!Object.values(LOCALES).includes(locale)) {
+    throw new Error(`Invalid locale. Supported: ${Object.values(LOCALES).join(', ')}`);
+  }
+
+  const requestBody = {
+    reportUnitId,
+    ignorePagination,
+    locale,
+    timeZone
+  };
+
+  // Add date range if provided
+  if (dateFrom) requestBody.dateFrom = dateFrom;
+  if (dateTo) requestBody.dateTo = dateTo;
+
+  const minimizedBody = createMinimizedJSON(requestBody);
+  const headers = await createAuthHeaders(partnerType, { ...authParams, requestBody: minimizedBody });
+
+  try {
+    const response = await axios.post(
+      `${getProductionUrl()}/data-retrieval`,
+      minimizedBody,
+      { headers }
+    );
+
+    return {
+      success: true,
+      data: response.data,
+      requestInfo: {
+        url: `${getProductionUrl()}/data-retrieval`,
+        method: 'POST',
+        requestBody: minimizedBody,
+        statusCode: response.status
+      }
+    };
+  } catch (error) {
+    throw new Error(`Failed to generate report: ${error.response?.data?.message || error.message}`);
+  }
+}
+
+/**
+ * Get report generation status
+ */
+export async function getReportStatus({
+  requestId,
+  partnerType,
+  ...authParams
+}) {
+  if (!requestId) {
+    throw new Error('requestId is required (UUID from report generation)');
+  }
+
+  const headers = await createAuthHeaders(partnerType, authParams);
+
+  try {
+    const response = await axios.get(
+      `${getProductionUrl()}/data-retrieval/request/${requestId}/status`,
+      { headers }
+    );
+
+    return {
+      success: true,
+      data: response.data,
+      requestInfo: {
+        url: `${getProductionUrl()}/data-retrieval/request/${requestId}/status`,
+        method: 'GET',
+        statusCode: response.status
+      }
+    };
+  } catch (error) {
+    throw new Error(`Failed to get report status: ${error.response?.data?.message || error.message}`);
+  }
+}
+
+/**
+ * Export report in specific format
+ */
+export async function exportReport({
+  requestId,
+  outputFormat = EXPORT_FORMATS.PDF,
+  partnerType,
+  ...authParams
+}) {
+  if (!requestId) {
+    throw new Error('requestId is required (UUID from report generation)');
+  }
+
+  if (!Object.values(EXPORT_FORMATS).includes(outputFormat)) {
+    throw new Error(`Invalid output format. Supported: ${Object.values(EXPORT_FORMATS).join(', ')}`);
+  }
+
+  const requestBody = {};
+  const headers = await createAuthHeaders(partnerType, { ...authParams, requestBody });
+
+  try {
+    const response = await axios.post(
+      `${getProductionUrl()}/data-retrieval/request/${requestId}/export/${outputFormat}`,
+      requestBody,
+      { headers }
+    );
+
+    return {
+      success: true,
+      data: response.data,
+      requestInfo: {
+        url: `${getProductionUrl()}/data-retrieval/request/${requestId}/export/${outputFormat}`,
+        method: 'POST',
+        statusCode: response.status
+      }
+    };
+  } catch (error) {
+    throw new Error(`Failed to export report: ${error.response?.data?.message || error.message}`);
+  }
+}
+
+/**
+ * Get export status
+ */
+export async function getExportStatus({
+  exportId,
+  partnerType,
+  ...authParams
+}) {
+  if (!exportId) {
+    throw new Error('exportId is required (UUID from export request)');
+  }
+
+  const headers = await createAuthHeaders(partnerType, authParams);
+
+  try {
+    const response = await axios.get(
+      `${getProductionUrl()}/data-retrieval/export/${exportId}/status`,
+      { headers }
+    );
+
+    return {
+      success: true,
+      data: response.data,
+      requestInfo: {
+        url: `${getProductionUrl()}/data-retrieval/export/${exportId}/status`,
+        method: 'GET',
+        statusCode: response.status
+      }
+    };
+  } catch (error) {
+    throw new Error(`Failed to get export status: ${error.response?.data?.message || error.message}`);
+  }
+}
+
+/**
+ * Download exported report
+ */
+export async function downloadExport({
+  exportId,
+  partnerType,
+  ...authParams
+}) {
+  if (!exportId) {
+    throw new Error('exportId is required (UUID from export request)');
+  }
+
+  const headers = await createAuthHeaders(partnerType, authParams);
+
+  try {
+    const response = await axios.get(
+      `${getProductionUrl()}/data-retrieval/export/${exportId}/download`,
+      {
+        headers,
+        responseType: 'arraybuffer' // For binary data (PDF, Excel, etc.)
+      }
+    );
+
+    return {
+      success: true,
+      data: response.data,
+      contentType: response.headers['content-type'],
+      contentLength: response.headers['content-length'],
+      requestInfo: {
+        url: `${getProductionUrl()}/data-retrieval/export/${exportId}/download`,
+        method: 'GET',
+        statusCode: response.status
+      }
+    };
+  } catch (error) {
+    throw new Error(`Failed to download export: ${error.response?.data?.message || error.message}`);
+  }
+}
+
+/**
+ * Cancel report generation
+ */
+export async function cancelReport({
+  requestId,
+  partnerType,
+  ...authParams
+}) {
+  if (!requestId) {
+    throw new Error('requestId is required (UUID from report generation)');
+  }
+
+  const requestBody = {};
+  const headers = await createAuthHeaders(partnerType, { ...authParams, requestBody });
+
+  try {
+    const response = await axios.put(
+      `${getProductionUrl()}/data-retrieval/${requestId}/cancel`,
+      requestBody,
+      { headers }
+    );
+
+    return {
+      success: true,
+      data: response.data,
+      requestInfo: {
+        url: `${getProductionUrl()}/data-retrieval/${requestId}/cancel`,
+        method: 'PUT',
+        statusCode: response.status
+      }
+    };
+  } catch (error) {
+    throw new Error(`Failed to cancel report: ${error.response?.data?.message || error.message}`);
+  }
+}
+
+/**
+ * Cancel export
+ */
+export async function cancelExport({
+  exportId,
+  partnerType,
+  ...authParams
+}) {
+  if (!exportId) {
+    throw new Error('exportId is required (UUID from export request)');
+  }
+
+  const requestBody = {};
+  const headers = await createAuthHeaders(partnerType, { ...authParams, requestBody });
+
+  try {
+    const response = await axios.put(
+      `${getProductionUrl()}/data-retrieval/${exportId}/cancel`,
+      requestBody,
+      { headers }
+    );
+
+    return {
+      success: true,
+      data: response.data,
+      requestInfo: {
+        url: `${getProductionUrl()}/data-retrieval/${exportId}/cancel`,
+        method: 'PUT',
+        statusCode: response.status
+      }
+    };
+  } catch (error) {
+    throw new Error(`Failed to cancel export: ${error.response?.data?.message || error.message}`);
+  }
+}