Server Method Invocation

The Server Method Invocation (SMI) feature enables you to build an app with a front-end component that can invoke a serverless component. To do this:

  1. In the front-end component (app.js), include a method to invoke the serverless component and pass an appropriate payload to the serverless component. By default, the serverless environment adds the installation parameters set during app installation to the payload.
  2. In the serverless component (server.js), include the app logic that runs based on the payload passed. Include the renderData() method to return success and failure responses to the front-end component.

Notes:
  • The rate limit for the serverless component is 50 triggers per minute.
  • The serverless component’s app execution timeout is five seconds.
  • The payload passed to the severless component should not exceed 100KB.

For a demonstration of how SMI works, see the SMI Freshdesk sample app.

Invoke the Serverless Component

  1. From the app’s root directory, navigate to the app.js file.
  2. Define the JSON payload that is to be passed to the method in the server.js file. In the following sample app.js code, options is the JSON payload that is passed.
  3. Include the client.request.invoke(“serverMethodName”, JSON_payload) method to invoke the serverless component. By default, the serverless environment adds an iparams object to the payload.
  4. Include functions to handle the response obtained from the serverless component.

Sample app.js code Copied Copy
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
var options = { "url": "https://api.github.com/users/sample" }; client.request.invoke("serverMethod", options).then( function(data) { // data is a json object with requestID and response. // The serverless environment generates the request ID. // The serverless method in server.js returns two objects (error,response). // data.response is the response object from the serverless method. console.log("Server method Request ID is: " + data.requestID); console.log("Server method response is: " + data.response); }, function(err) { // err is a json object with requestID, status, and message. // The serverless environment generates the request ID. // The serverless method in server.js returns two objects (error,response). // The error object contains the status and message attributes. // err.status is the error.status attribute. // err.message is the error.message attribute. console.log("Request ID: " + err.requestID); console.log("error status: " + err.status); console.log("error message: " + err.message); });
EXPAND ↓
Sample JSON_payload Copied Copy
1
2
3
4
5
6
7
{ "url": "https://api.github.com/users/sample", "iparams": { "<iparam1>": "<value1>", "<iparam2>": "<value2>" } }
Send Response to the Front-end Component

After the app logic in the server method runs, the server method sends an appropriate response to the front-end component. To enable this:

  1. Navigate to the server.js file. In the exports code block, define the server method that is called from the front-end component. Place the app logic inside the server method.
  2. Use the renderData(error, data) method to return a response to the front-end component.
    Notes:
    • error and data are passed as JSON objects to the caller method. Ensure that the first argument of renderData(error, data) is always the error object. For success responses, ensure to pass null as the first argument.

    • error is an object with status and message attributes. data is an object with valid <key>: <value> pairs.

    • The serverless environment adds a requestID attribute, to the error or data object.
  3. To send a success response, use the renderData() method as follows: Copied Copy
    1
    2
    3
    4
    5
    6
    exports = { serverMethod: function(options) { // app logic resides here renderData(null, { "key": "value" }); } }
    The front-end component can render the success response as follows: Copied Copy
    1
    2
    3
    4
    { requestID: "2edc13f8-3b81-4ade-b857-8d8e316fa87c", response: { "key": "value" } }
  4. To send a failure response, use the renderData() method as follows: Copied Copy
    1
    2
    3
    4
    5
    6
    exports = { serverMethod: function(options) { var error = { status: 403, message: "Error while processing the request" }; renderData(error); } }
    The front-end component can render the failure response as follows: Copied Copy
    1
    2
    3
    4
    5
    { "requestID": "2edc13f8-3b81-4ade-b857-8d8e316fa87c", "status": 403, "message": "Error while processing the request" }
    If error.statusis not present, the default status code of 500 is used as the error status. If the error object in renderData(error) is of incorrect JSON format, error.status value is 400 and error.message value is “The error should be a JSON Object with a message or a status parameter.” The front-end component can render this error as follows: Copied Copy
    1
    2
    3
    4
    5
    { "requestID": "2edc13f8-3b81-4ade-b857-8d8e316fa87c", "status": 400, "message": "The error should be a JSON Object with a message or a status parameter." }
Note: If the server method does not return a response, the app execution timeout error occurs.
Test the SMI app

For information on how to test an SMI app, see Test the App