import MoleClientProxified from 'mole-rpc/MoleClientProxified';
 
// choose any transports here
// https://www.npmjs.com/search?q=keywords:mole-transport
const transport = new TransportClient();
const calculator = new MoleClientProxified({ transport });
 
const result1 = await calculator.sum(1, 3);
const result2 = await calculator.asyncSum(2, 3);
 
// Send JSON RPC notification (fire and forget)
// server will send no response
await calculator.notify.sum(3, 2);

import MoleClient from 'mole-rpc/MoleClient';
 
// choose any transports here
// https://www.npmjs.com/search?q=keywords:mole-transport
const transport = new TransportClient();
const client = new MoleClient({ transport });
 
const result1 = await client.callMethod('sum', [1, 3]);
const result2 = await client.callMethod('sum', [2, 3]);
 
// Send JSON RPC notification (fire and forget)
// server will send no response
await client.notify('sum', [2, 3]);

import MoleServer from 'mole-rpc/MoleServer';
 
class Calculator {
    sum(a, b) {
        return a + b;
    }
 
    asyncSum(a, b) {
        return new Promise((resolve, reject) => {
            resolve(this.sum(a, b));
        });
    }
 
    _privateMethod() {
        // will not be exposed
    }
}
 
const calculator = new Calculator();
 
// choose any transports here
// https://www.npmjs.com/search?q=keywords:mole-transport
const transports = [new TransportServer()];
 
const server = new MoleServer({ transports: [] });
server.expose(calculator);
 
await server.run();

import MoleServer from "mole-rpc/MoleServer";
 
function sum(a, b) {
   return a+b;
}
 
function asyncSum(a, b) {
   return new Promise((resolve, reject) {
      resolve( sum(a, b) );
   });
}
 
// choose any transports here
// https://www.npmjs.com/search?q=keywords:mole-transport
const transports = [ new TransportServer() ];
 
const server = new MoleServer({ transports });
server.expose({
   sum,
   asyncSum
});
 
await server.run();

 
 
// Proxified client: explicit call
await calculator.callMethod.sum(1, 2); // the same as "calculator.sum(1, 2)"
// Can be usefull if your server method is a reserverd name.
// For example to make a call to remote "notify" method.
await proxifiedClient.callMethod.notify("Hello");
 
// Proxified client: run request in parallel
const promises = [
   calculator.sum(1, 2);
   calculator.notify.sum(1, 2);
];
 
const results = await Promise.all(promises);
 
// Simple client: run in parallel
const promises = [
   client.callMethod('sum', [1, 2]);
   client.notify('sum', [1, 2]);
];
 
const results = await Promise.all(promises);
 
// Simple client: run batch
const results = await client.runBatch([
   ['sum', [1, 3]],
   ['sum', [2, 5], 'notify'],
   ['sum', [7, 9], 'callMethod'], // "callMethod" is optional
   [methodName, params, mode]
]);
 
 
// Result structure
[
   {success: true, result: 123},
   null, // no response for notification
   {success: false, error: errorObject}
];