soap-sympa

A fork to provide SOAP capabilities to node to use the Sympa SOAP interface. This fork has some very dirty hacks inside and is based on the node SOAP client

This module is a fork from node-soap with some dirty hacks, to make the sympa-soap services run.

For Sympa to run, we adopted the build of namespaces (obviously perl soap lite treats this differently then the standard SOAP), and also we adopted the parameter handling. For the parameter handling to work, the parameters need to be named using the array variable name "parameters".

This module lets you connect to web services using SOAP. It also provides a server that allows you to run your own SOAP services.

Features:

  • Very simple API
  • Handles both RPC and Document schema types
  • Supports multiRef SOAP messages (thanks to @kaven276)
  • Support for both synchronous and asynchronous method handlers
  • WS-Security (currently only UsernameToken and PasswordText encoding is supported)

Install with npm:

  npm install soap
  var soap = require('soap');
  var url = 'http://example.com/wsdl?wsdl';
  var args = {name: 'value'};
  soap.createClient(url, function(errclient) {
      client.MyFunction(args, function(errresult) {
          console.log(result);
      });
  });

wsdl is an xml string that defines the service.

  var myService = {
      MyService: {
          MyPort: {
              MyFunctionfunction(args) {
                  return {
                      name: args.name
                  };
              }
 
              // This is how to define an asynchronous function. 
              MyAsyncFunctionfunction(argscallback) {
                  // do some work 
                  callback({
                      name: args.name
                  })
              }
          }
      }
  }
 
  var xml = require('fs').readFileSync('myservice.wsdl', 'utf8'),
      server = http.createServer(function(request,response) {
          response.end("404: Not Found: "+request.url)
      });
 
  server.listen(8000);
  soap.listen(server, '/wsdl', myService, xml);

If the log method is defined it will be called with 'received' and 'replied' along with data.

  server = soap.listen(...)
  server.log = function(typedata) {
    // type is 'received' or 'replied' 
  };

If server.authenticate is not defined no authentation will take place.

  server = soap.listen(...)
  server.authenticate = function(security) {
    var created, nonce, password, user, token;
    token = security.UsernameToken, user = token.Username,
            password = token.Password, nonce = token.Nonce, created = token.Created;
    return user === 'user' && password === soap.passwordDigest(nonce, created, 'password');
  };

This is called prior to soap service method If the method is defined and returns false the incoming connection is terminated.

  server = soap.listen(...)
  server.authorizeConnection = function(req) {
    return true; // or false 
  };

An instance of Client is passed to the soap.createClient callback. It is used to execute methods on the soap service.

  client.describe() // returns 
    {
      MyService: {
        MyPort: {
          MyFunction: {
            input: {
              name: 'string'
            }
          }
        }
      }
    }
  client.setSecurity(new WSSecurity('username', 'password'))
  client.MyFunction({name: 'value'}, function(errresult) {
      // result is a javascript object 
  })
  client.MyService.MyPort.MyFunction({name: 'value'}, function(errresult) {
      // result is a javascript object 
  })
  • soapHeader Object({rootName: {name: "value"}}) or strict xml-string
  • name Unknown parameter (it could just a empty string)
  • namespace prefix of xml namespace
  • xmlns URI

WSSecurity implements WS-Security. UsernameToken and PasswordText/PasswordDigest is supported. An instance of WSSecurity is passed to Client.setSecurity.

  new WSSecurity(username, password, passwordType)
    //'PasswordDigest' or 'PasswordText' default is PasswordText