JSON-RPC Notifications Example

// Regular JSON-RPC request{
  "jsonrpc": "2.0",
  "method": "updateUser",
  "params": { "userId": 123, "name": "John Doe" },
  "id": 1
}// JSON-RPC notification (no id field){
  "jsonrpc": "2.0",
  "method": "logEvent",
  "params": { "event": "user_login", "userId": 123 }
}

const express = require('express');
const bodyParser = require('body-parser');

const app = express();
const PORT = 3000;

// Middleware to parse JSON request body
app.use(bodyParser.json());

// Simple in-memory log for demonstration
const eventLog = [];

// JSON-RPC request handler
app.post('/jsonrpc', (req, res) => {
  const request = req.body;
  
  // Validate JSON-RPC request
  if (!request.jsonrpc || request.jsonrpc !== '2.0' || !request.method) {
    return res.json({
      jsonrpc: '2.0',
      error: {
        code: -32600,
        message: 'Invalid Request'
      },
      id: request.id || null
    });
  }

  // Check if it's a notification (no id field)
  const isNotification = request.id === undefined;

  // Process method calls
  let result;
  let error;

  try {
    switch (request.method) {
      // Regular methods that return a response
      case 'echo':
        result = request.params;
        break;
      
      case 'add':
        if (!Array.isArray(request.params) || request.params.length !== 2) {
          throw { code: -32602, message: 'Invalid params' };
        }
        result = request.params[0] + request.params[1];
        break;
      
      // Methods often used as notifications
      case 'logEvent':
        if (!request.params || !request.params.event) {
          throw { code: -32602, message: 'Invalid params, event is required' };
        }
        
        // Add timestamp to the event
        const logEntry = {
          ...request.params,
          timestamp: new Date().toISOString()
        };
        
        // Store in our log
        eventLog.push(logEntry);
        console.log('Event logged:', logEntry);
        
        result = true;
        break;
        
      case 'updateStatus':
        if (!request.params || !request.params.status) {
          throw { code: -32602, message: 'Invalid params, status is required' };
        }
        
        console.log('Status updated:', request.params.status);
        result = true;
        break;
        
      default:
        throw { code: -32601, message: 'Method not found' };
    }
  } catch (e) {
    error = {
      code: e.code || -32603,
      message: e.message || 'Internal error'
    };
  }

  // For notifications, don't send a response
  if (isNotification) {
    // Log errors from notifications for debugging
    if (error) {
      console.error('Error processing notification:', error);
    }
    
    // End the request without a response body
    return res.status(204).end();
  }

  // For regular requests, build and send a response
  const response = {
    jsonrpc: '2.0',
    id: request.id
  };

  if (error) {
    response.error = error;
  } else {
    response.result = result;
  }

  res.json(response);
});

// Endpoint to view the event log (for demonstration purposes)
app.get('/log', (req, res) => {
  res.json(eventLog);
});

// Start the server
app.listen(PORT, () => {
  console.log(`JSON-RPC server running at http://localhost:${PORT}`);
});

const fetch = require('node-fetch');

class JsonRpcClient {
  constructor(url) {
    this.url = url;
    this.id = 1;
  }

  // Method for regular JSON-RPC requests (with response)
  async call(method, params) {
    const request = {
      jsonrpc: '2.0',
      method,
      params,
      id: this.id++
    };

    const response = await fetch(this.url, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json'
      },
      body: JSON.stringify(request)
    });

    // Parse the JSON response
    const result = await response.json();

    if (result.error) {
      throw new Error(`Error ${result.error.code}: ${result.error.message}`);
    }

    return result.result;
  }

  // Method for sending notifications (no response expected)
  async notify(method, params) {
    const notification = {
      jsonrpc: '2.0',
      method,
      params
      // No id field for notifications
    };

    const response = await fetch(this.url, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json'
      },
      body: JSON.stringify(notification)
    });

    // We don't expect a response body, but we should check the status
    if (response.status !== 204) {
      console.warn(`Unexpected status code ${response.status} for notification`);
    }

    // No return value for notifications
    return;
  }
}

// Create client instance
const client = new JsonRpcClient('http://localhost:3000/jsonrpc');

// Example usage
async function runExamples() {
  try {
    // Regular request - we wait for a response
    console.log('Sending a regular request...');
    const result = await client.call('add', [5, 3]);
    console.log('Result of 5 + 3:', result);

    // Send some notifications - we don't wait for responses
    console.log('\nSending notifications...');
    
    // Log a user login event
    await client.notify('logEvent', {
      event: 'user_login',
      userId: 123,
      details: { ip: '192.168.1.1', browser: 'Chrome' }
    });
    console.log('Login event notification sent');

    // Update application status
    await client.notify('updateStatus', {
      status: 'active',
      component: 'backend',
      load: 0.75
    });
    console.log('Status update notification sent');

    // Send another regular request to view the log
    console.log('\nChecking server log...');
    const logUrl = 'http://localhost:3000/log';
    const logResponse = await fetch(logUrl);
    const logData = await logResponse.json();
    console.log('Server event log:', JSON.stringify(logData, null, 2));
    
  } catch (e) {
    console.error('Error:', e);
  }
}

// Run the examples
runExamples();