integrator.io extension frameworks

Tom Santiago

Updated September 22, 2024 14:11

integrator-extension

Celigo's integrator-extension provides an easy-to-use framework for extending integrator.io through various functions that you can host on multiple environments (both server-based or server-less). The integrator-extension supports execution of extension functions through two extension types:

express-integrator-extension: Express-based app running on a server
lambda-integrator-extension: Amazon Web Services (AWS) Lambda hosting

Installation

Using npm:

$ npm i --save integrator-extension

Configuration

The integrator-extension provides a loadConfiguration function that accepts a configuration object. Use the configuration object to set up extension functions for both do-it-yourself (DIY) integrations and connectors.

Common configuration properties

diy: This property allows you to create an integration from scratch in integrator.io. Use this field to assign a value containing all hook and wrapper functions for the integration.

Note

The configuration object can have only one diy field.

connectors: A connector represents a fully functional standalone integration that any user can install directly from the integrator.io Marketplace. Set the value for this field to an object containing a list of key-value pairs, where each key is a _connectorId of a given connector and the value is the node module (or object) containing the hooks, wrappers, installer, uninstaller and settings functions for that connector. The configuration properties available vary according to extension type. See the repositories for more details.

Note

The configuration object can have only one connectors field.

Extension functions

Extension functions allow you to write custom code to further customize and enhance integrator.io. Integrator.io supports the following functions:

Note

In this topic, the term value should be interpreted as defined at www.json.org, unless mentioned otherwise.

preSavePage (options, callback)

This function is invoked before saving a page of data that the export retrieved for further processing. You can use this function to add or delete records or modify the existing records in the data passed to the hook preSavePage.

The options argument has the following fields:

Field name	Description
bearerToken	A one-time bearer token which can be used to invoke selected integrator.io API routes.
data	An array of records representing one page of data. An individual record can be an object {} , or an array [] depending on the data source.
errors	An array of errors where each error has the following structure: { code: '', message: '', source: '' }
_exportId	The _exportId currently running.
_connectionId	The _connectionId currently running.
_flowId	The _flowId currently running.
_integrationId	The _integrationId currently running.
_parentIntegrationId	The parent of the _integrationId currently running.
pageIndex	0 based. Context is the batch export currently running.
lastExportDateTime	delta exports only.
currentExportDateTime	delta exports only.
settings	All custom settings in scope for the export currently running.

The function returns a callback object with the following fields:

Field name	Description
data	your modified data.
errors	your modified errors.
abort	instruct the batch export currently running to stop generating new pages of data.

Note

Throwing an exception signals a fatal error and stops the flow.

exports.preSavePageFunction = function (options, callback) {
  // sample code that passes on exported data
  return callback(error, {
    data: options.data,
    errors: options.errors,
    abort: false
  })
}

preMap (options, callback)

This function is invoked before the fields are mapped to their respective fields in the objects to be imported. This function can be used to reformat the record’s fields before they get mapped.

The name of the function can be changed to anything you like.

The options argument has the following fields:

Field name	Description
bearerToken	A one-time bearer token which can be used to invoke selected integrator.io API routes.
data	An array of records representing the page of data before it has been mapped. An individual record can be an object {} or an array [], depending on the data source.
_importId	The _importId of the import for which the hook is defined.
_connectionId	The _id of the connection linked to the import for which the hook is defined.
_flowId	the _id of the flow linked to the import for which the hook is defined.
_integrationId	The _id of the integration linked to the import for which the hook is defined.
_parentIntegrationId	The parent of the _integrationId currently running.
settings	A container object for all the integration app settings associated with the integration (applicable to integration apps only).

The function returns an array, and the length must match the options.data array length. Each element in the array represents the actions that should be taken on the record at that index.

Each element in the array should have the following fields:

Argument name

Description

data

The record that should be passed along for processing, whether or not it has yet been modified. An individual record can be an object {} or an array [] depending on the data source.

errors

Used to report one or more errors for the specific record. Each error must have the following structure:

{
    code: '',
    message: '',
    source: ''
}

Returning an empty object {} for a specific record indicates to integrator.io that the record should be ignored.

Throwing an exception fails the entire page of records.

exports.preMapFunction = function (options, callback) {
  return callback(error, options.data.map((d) => { return { data: d }})
}

postMap (options, callback)

This function is invoked after the fields in the source objects have been mapped to their respective fields in import object. This function can be used to further modify the mapped data.

The name of the function can be changed to anything you like.

The function is passed an options argument with the following fields:

Field name	Description
bearerToken	a one-time bearer token which can be used to invoke selected integrator.io API routes.
preMapData	an array of records representing the page of data before it was mapped. An individual record can be an object {} , or an array [] depending on the data source.
postMapData	an array of records representing the page of data after it was mapped. An individual record can be an object {} , or an array [] depending on the data source.
_importId	the _importId currently running.
_connectionId	the _connectionId currently running.
_flowId	the _flowId currently running.
_integrationId	the _integrationId currently running.
_parentIntegrationId	The parent of the _integrationId currently running.
settings	a container object for all the integration app settings associated with the integration (applicable to integration apps only).

The function returns an array, and the length must match the options.data array length. Each element in the array represents the actions that should be taken on the record at that index.

Each element in the array should have the following fields:

Argument Name

Description

data

The modified (or unmodified) record that should be passed along for processing. An individual record can be an object {} or an array [] depending on the data source.

errors

Used to report one or more errors for the specific record. Each error must have the following structure:

{
    code: '',
    message: '',
    source: ''
}

Returning an empty object {} for a specific record indicates to integrator.io that the record should be ignored.

Returning both data and errors for a specific record indicates that integrator.io should process the record and also log errors on the job.

Throwing an exception fails the entire page of records.

exports.postMapFunction = function (options, callback) {
  return callback(error, options.postMapData.map((d) => { return { data: d }}))
}

postSubmit (options, callback)

This function is invoked after the import processes the records. You can use it to further process imported objects and modify the response data received from an import’s success and error cases. You can also use it to invoke other processes to run after the import.

The name of the function can be changed to anything you like.

The function is passed an options argument with the following fields:

Field name	Description
bearerToken	a one-time bearer token which can be used to invoke selected integrator.io API routes.
preMapData	an array of records representing the page of data before it was mapped. An individual record can be an object {} , or an array [] depending on the data source.
postMapData	an array of records representing the page of data after it was mapped. An individual record can be an object {} , or an array [] depending on the data source.
responseData	an array of responses for the page of data that was submitted to the import application. An individual response will have the following structure: { statusCode: 200/422/401, errors: [], ignored: true/false, id: '', _json: {}, dataURI: '' }
statusCode	200 is a success. 422 is a data error. 401 means the connection went offline (typically due to an authentication or incorrect password issue).
errors	[{code: '', message: '', source: ''}]
ignored	true if the record was filtered/skipped, false otherwise.
id	the id from the import application response.
_json	the complete response data from the import application.
dataURI	if possible, a URI for the data in the import application (populated only for errored records).
_importId	the _importId of the import for which the hook is defined.
_connectionId	the _id of the connection linked to the import for which the hook is defined.
_flowId	the _id of the flow linked to the import for which the hook is defined.
_integrationId	the _id of the integration linked to the import for which the hook is defined.
_parentIntegrationId	The parent of the _integrationId currently running.
settings	a container object for all the integration apps settings associated with the integration (applicable to integration apps only).

The function is expected to return the responseData array provided by options.responseData . The length of the responseData array must remain unchanged. You can modify elements within the responseData array to enhance error messages, modify the complete _json response data, and so forth.

Throwing an exception fails the entire page of records.

exports.postSubmitFunction = function (options, callback) {
  return callback(error, options.responseData)
}

postResponseMap

The name of the function can be changed to anything you like.

This hook runs immediately after response mappings and regular mappings. Use this hook to process records after response mapping before they are passed on to downstream applications in your flow. Any changes that you made to records with the postResponseMap hook will affect ALL downstream applications. You do not need to define a response/results mapping to use this hook. You could also use this hook instead to perform the same mapping type logic. For more detailed information about how postResponseMap works, please read the help text provided in the default function stub.

The function's options argument has the following fields:

Field Name	Description
bearerToken	a one-time bearer token which can be used to invoke selected integrator.io API routes.
postResponseMapData	an array of records representing the page of data after response mapping is completed. A record can be an object {} or array [] depending on the data source.
responseData	an array of responses for the page of data that was submitted to the import application. An individual response will have the following structure: { statusCode: 200/422/401, errors: [], ignored: true/false, id: '', _json: {}, dataURI: '' }
statusCode	200 is a success. 422 is a data error. 401 means the connection went offline (typically due to an authentication or incorrect password issue).
errors	[{code: '', message: '', source: ''}]
ignored	true if the record was filtered/skipped, false otherwise.
data	the array of records returned by the export application. This field is available for exports only.
id	the id from the import application response.
_json	the complete response data from the import application.
dataURI	if possible, a URI for the data in the import application (populated only for errored records).
oneToMany	as configured on your export or import resource.
pathToMany	as configured on your export or import resource.
_exportId	the _exportId currently running.
_importId	the _importId currently running.
_connectionId	the _connectionId currently running.
_flowId	the _id of the flow linked to the import for which the hook is defined.
_integrationId	the _id of the integration linked to the import for which the hook is defined.
_parentIntegrationId	The parent of the _integrationId currently running.
settings	a container object for all the integration apps settings associated with the integration (applicable to integration apps only).

The function needs to return the postResponseMapData array provided by options.postResponseMapData.

The length of postResponseMapData MUST remain unchanged. Elements within postResponseMapData can be changed however needed.

Throwing an exception will signal a fatal error and fail the entire page of records.

exports.postResponseMapFunction = function (options, callback) {
  return callback(error, options.postResponseMapData)
}

postAggregate

postAggregrateFunction: The name of the function can be changed to anything you like.

The function is passed an options argument with the following fields:

Field Name	Description
bearerToken	a one-time bearer token which can be used to invoke selected integrator.io API routes.
postAggregateData	A container object with the following fields:
success	True if data aggregation was successful, false otherwise.
_json	information about the aggregated data transfer. For example, the name of the aggregated file on the FTP site.
code	error code if data aggregation failed.
message	error message if data aggregation failed.
source	error source if data aggregation failed.
_importId	The _importId of the import for which the hook is defined.
_connectionId	The _id of the connection linked to the import for which the hook is defined.
_flowId	The _id of the flow linked to the import for which the hook is defined.
_integrationId	The _id of the integration linked to the import for which the hook is defined.
_parentIntegrationId	The parent of the _integrationId currently running.
settings	a container object for all the integration apps settings associated with the integration (applicable to integration apps only).

The function doesn't need a return value.

Throwing an exception signals a fatal error.

exports.postAggregateFunction = function (options, callback) {
  return callback(error)
}

formInit

The name of the function can be changed to anything you like.

The function will be passed one options argument that has the following fields:

Field Name	Description
bearerToken	a one-time bearer token which can be used to invoke selected integrator.io API routes.
resource	the resource being viewed in the UI.
parentResource	the parent of the resource being viewed in the UI.
license	integration apps only. the license provisioned to the integration.
parentLicense	integration apps only. the parent of the license provisioned to the integration.

The function returns a form object for the UI to render.

Throwing an exception signals an error.

exports.formInitFunction = function (options, callback) {
  return callback(error, options.resource.settingsForm.form)
}

preSave

The name of the function can be changed to anything you like.

The function is passed an options argument with the following fields:

Field Name	Description
bearerToken	a one-time bearer token which can be used to invoke selected integrator.io API routes.
newResource	the resource being viewed in the UI.
oldResource	the parent of the resource being viewed in the UI.

The function returns the newResource object to save.

Throwing an exception signals an error.

exports.preSaveFunction = function (options, callback) {
  return callback(error, options.newResource)
}

step

This function represents one step in the installation or uninstallation process. The step functions can be used to create resources, validate bundles, etc.

Field Name	Description
bearerToken	a one-time bearer token which can be used to invoke selected integrator.io API routes.
formSubmission	form steps only.
_connectionId	connection steps only.
resource	the resource being viewed in the UI.
parentResource	the parent of the resource being viewed in the UI.
license	integration apps only. the license provisioned to the integration.
parentLicense	integration apps only. the parent of the license provisioned to the integration.

The function does not need to return anything.

Throwing an exception signals an error.

exports.stepFunction = function (options, callback) {
  return callback(error)
}

initChild

Use this function to create a child integration.

Field Name	Description
bearerToken	a one-time bearer token which can be used to invoke selected integrator.io API routes.
parentIntegration	the parent of the child integration being initialized.
parentLicense	integration apps only. the parent of the license provisioned to the integration.

The function does not need to return anything.

Throwing an exception signals an error.

exports.initChild = function (options) {
  return { name: "child integration", installSteps: [...] }
}

update

Use this function to update the integrations belonging to a connector. Whenever, new versions of the connector need to be released or there are any new features in a connector, use the update function to make the required changes for integrations installed in user accounts.

The name of the function can be changed to anything you like.

The function is passed an options argument that has the following fields:

Field Name	Description
bearerToken	a one-time bearer token which can be used to invoke selected integrator.io API routes.
resource	the resource being updated
license	integration apps only. the license provisioned to the integration.

The function does not need to return anything.

Throwing an exception signals an error.

exports.updateFunction = function (options, callback) {
  return callback(error)
}

changeEdition

The name of the function can be changed to anything you like.

The function will be passed one options argument that has the following fields:

Field Name	Description
bearerToken	a one-time bearer token which can be used to invoke selected integrator.io API routes.
fromEdition	the edition currently installed.
toEdition	the new edition.
integration	the integration being changed.
license	integration apps only. the license provisioned to the integration.

The function does not need to return anything.

Throwing an exception signals an error.

exports.changeEditionFunction = function (options, callback) {
  return callback(error)
}

ping

Call this function to verify whether the connection defined for the wrapper adaptor is valid. The options object contains the following properties:

Field Name	Description
bearerToken	a one-time bearer token which can be used to invoke selected integrator.io API routes.
connection	form steps only.
_importId or _exportId	connection steps only.

The function calls back with the following arguments:

Argument Name

Description

err

an error object to signal a fatal exception and will fail the entire page of records.

response

The response object provides information about whether the ping was successful or not. It contains two fields statusCode and errors . Set statusCode to 401 and populate errors if the connection fails. Else, set statusCode to 200.

{ statusCode: 200/401, errors: [{message: 'error message', code: 'error code'}]}

exports.pingConnectionFunction = function (options, callback) {
 return callback(error, response)
}

export

A wrapper export allows you to write a full export and substitute the actual implementation of an integrator.io export. The wrapper export function returns back pages of data and is called by integrator.io again and again until all the records have been returned to integrator.io.

Field Name	Description
bearerToken	a one-time bearer token which can be used to invoke selected integrator.io API routes.
connection	The connection object containing the connection configuration {encrypted: {...}, unencrypted: {...}} encrypted and unencrypted are JSON objects that were saved on the corresponding wrapper connection.
type	the export type can have the values delta , type or once. If its not set then it should be assumed that all records need to be exported.
delta	This field is set only when export type is delta. It contains a JSON object having two properties {dateField: ..., lastExecutionTime: ...} dateField is the field to be used to query records that need to be exported. lastExecutionTime (in milliseconds) is the date on which the corresponding export job was last run.
once	This field is set only when export type is once and contains a JSON object having one property {booleanField: ...} booleanField is the field to be used to query records that need to be exported.
test	This field is set only when export type is test and contains a JSON object having one property {limit: ...} limit is the maximum number of records that should be fetched.
state	This field allows you to pass information between successive export calls. The state returned as part of a response for a previous call will be passed as is.
_exportId	_id of the wrapper export.
settings	The container for all integrator.io settings data for an integration (applicable only to connectors).
configuration	The configuration provided for the wrapper export. Can be used to further customize the wrapper.
data	This field is set only when the export is used as a pageProcessor in an orchestrated flow and contains the data that is generated by the previous pageGenerator or pageProcessor before this export is invoked.

The function calls back with the following arguments:

Argument Name

Description

err

Error object to convey a fatal error has occurred. This will halt the export process.

response

The response should contain a JSON object where the following properties can be set.

connectionOffline: A boolean value to specify if connection went offline during the course of the export. If set to true this will make the wrapper connection offline and stop the export process.

data: An array of values where each value is a record that has been exported.

errors: An array of JSON objects where each element represents error information in the format

{message: 'error message', code: 'error code'}

that occurred during the export.

lastPage : A boolean to convey integrator.io that this is the last page of the export process. No more calls will be made once lastPage is set to true.

state: An object which can be used to specify the current state of the export process that will be passed back in the next call to the wrapper function.

exports.exportFunction = function (options, callback) {
  return callback(error, response)
}

Note

No further calls will be made to a wrapper function if the same response is sent more than five times to integrator.io during an export process by the wrapper function. integrator.io will consider this as an infinite loop and stop the export process.

import

A wrapper import allows you to write a full end-to-end import and substitute the actual implementation of an integrator.io import. The options object contains the following properties:

Field Name	Description
bearerToken	a one-time bearer token which can be used to invoke selected integrator.io API routes.
connection	the connection object containing the connection's configuration { encrypted: {...}, unencrypted: {...} } encrypted and unencrypted are JSON objects which were saved on the corresponding wrapper connection.
preMapData	an array of values which was used for mapping by the import.
postMapData	an array of values which was obtained after the mapping was done based on the mapping configuration set for the import.
__importId	_id of the wrapper import.
settings	the container for all integrator.io settings data for an integration (applicable only to connectors).
configuration	the configuration provided for the wrapper import. Can be used to further customize the wrapper.

The function calls back with the following arguments:

Argument Name

Description

err

Error object to convey a fatal error has occurred. This will halt the import process.

response

Response is an array of JSON objects where each object should follow the following structure:

{statusCode: 200/401/422, id: string, ignored: boolean, errors: [{code, message}]}

statusCode should be set to 200 when the import was successful, 401 when the operation failed with an authorization or connection error, and 422 when some other error occurred during the process.

id is the identifier of the record in the target system.

ignored should be set to true if the record was ignored and not imported.

errors is an array of JSON objects representing the list of the errors that occurred while importing the records

[{message: 'error message', code: 'error code'}]

errors can also be used with statusCode 200 to indicate partial success (for example, import succeeded without a field).

exports.importFunction = function (options, callback) {
  return callback(error, response)
}

express-integrator-extension

This module extends the integrator-extension and can be used to create an express app which exposes an API that is used by integrator.io to invoke the extension functions and get back the results. This extension type is based on the stack of type server in integrator.io. The baseURI for the API will be same as the hostURI of the stack and the stack's systemToken is used to authenticate the requests made to the API. You can host the express app on a single server or a set of servers behind a load balancer to scale as needed.

express-integrator-extension Installation

Using npm:

$ npm i --save express-integrator-extension

express-integrator-extension usage

var expressExtension = require('express-integrator-extension')
expressExtension.createServer(config, function (err) {
})
expressExtension.stopServer(function (err) {
})

express-integrator-extension createServer(config, callback)

The createServer function loads the configuration and starts an express app. You can set the following configuration fields along with the fields mentioned in integrator-extension configuration:

Field name	Description
port	This optional field specifies the port that should be used by the express server. Default port is 80.
systemToken	This required field needs to be set to the stack's systemToken that you created in integrator.io.
maxSockets	This optional field is to customize the value for https.globalAgent.maxSockets . Default value is set to Infinity.
winstonInstance	This optional field is used to pass the winston instance which will be used to log information. By default logs go only to the console output.
stopServer(callback)	The stopServer function stops the express app from listening on the designated port.

Getting Started

Use the following steps to create a working Express-based stack:

Create a stack in integrator.io.
Log in into integrator.io.
Click the Options field in the top right corner, and select Stacks.
Click the New Stack button.
Give an appropriate name for the stack.
Select Server as the Type.
Set the Host field to the URI hosting the project. If the URI is not available, you can leave it blank and update the stack at a later time.
Click Save to create the stack.
You will be redirected to the stacks page. To find the token value, click click to display under the System Token column corresponding to the stack you created.
Write code
Run npm init to create node project in a new folder.
Run npm i --save express-integrator-extension.

Create a new file functions.js and save the following extension functions in it:

 var obj = { hooks: { preSaveFunction: function (options, callback) { // your code }
},
wrappers: { pingFunction: function (options, callback) { // your code } } };
module.exports = obj;

Create a new file index.js and save the following code in it. Either the DIY or connectors configuration should be used.

  var expressExtension = require('express-integrator-extension');
  var functions = require('./functions');
  var systemToken = '************'; // Set this value to the systemToken of the stack created in integrator.io
  var options = {
  diy: functions,
  // connectors: { _connectorId: functions }, // for connectors
  systemToken: systemToken  };
  expressExtension.createServer(options, function (err) {
  });

Host the node project on a single server or a set of servers behind a load balancer to scale as needed. Any server based hosting environment like AWS EC2 , AWS Opsworks , Rackspace Cloud , Google Cloud , Heroku, etc. can be used to run the code. Update the stack in integrator.io with the endpoint URI of your server or load balancer.

Now, the stack is ready for use and it can be referenced from appropriate exports, imports and connections. To maintain security, systemToken should be stored securely on your server environment. Please refer to best practices of the respective system that you chose to run the express app.

lambda-integrator-extension

This module extends integrator-extension and can be used to host extension functions on AWS Lambda . This allows to run the extension code in a server-less environment that helps in simplifying the deployment and maintenance process. To use this module your stack must be of type lambda in integrator.io. integrator.io uses the AWS IAM User Access Keys provided on the stack to invoke the extension functions and get the results. The associated AWS IAM user must be assigned "lambda:InvokeFunction" permission for the AWS Lambda Function provided on the stack via an attached IAM policy. Detailed steps to create an AWS Lambda stack in integrator.io are given below.

lambda-integrator-extension installation

Using npm:

$ npm i --save lambda-integrator-extension

lambda-integrator-extension usage

var lambdaExtension = require('lambda-integrator-extension')
exports.handler = lambdaExtension.createHandler(config)

lambda-integrator-extension createHandler(callback)

The createHandler function loads the configuration and returns the handler that should be used when creating the AWS Lambda Function. The result of execution of createHandler function needs to be assigned to exports.handler which in turn executes whenever integrator.io sends a request to execute any of the extension functions.

lambda-integrator-extension Getting Started

Use the following steps to create a working AWS Lambda stack.

Create an AWS account. As part of the sign-up validation procedure you will receive a phone call.
Create an IAM Policy.
1. Go to Identity And Access Management page by clicking Security Credentials from the drop down under your account name.
2. On the navigation column on the left, choose Policies.
3. Click Create Policy at the top of the page.
4. On the Create Policy page, select Create Your Own Policy.
5. Give an appropriate name for the policy in name field.
6. Add the following in the policy document text box:
```
{
 "Version": "2012-10-17",
 "Statement": [{
 "Effect": "Allow",
 "Action": [
 "lambda:InvokeFunction"
 ],
 "Resource": [
 "*"
 ]
 }]
 } 
```
7. To validate the policy click Validate Policy.
8. If the validation passes then click Create Policy.
Create an IAM User in AWS
1. Go to the Identity And Access Management page.
2. Select Users in the left pane.
3. On the Create Users page enter the user name.
4. Ensure that Generate an access key for each user is checked.
5. Click Create.
6. Click Show User Security Credentials and make a note of the Access Key ID and Secret Access Key.
7. Click the Permissions tab for the user and attach the policy created above.

Write code

Run npm init to create the node project in a new folder.
Run npm i --save lambda-integrator-extension.

Create a new file functions.js and save the following extension functions in it.

 var obj = {
 hooks: {
 preSaveFunction: function (options, callback) {
 // your code
 }
 },
wrappers: {
 pingFunction: function (options, callback) {
 // your code
 }
 }
 }
module.exports = obj

Create a new file index.js and save the following code in it. Use either the DIY or connectors configuration.

 var extension = require('lambda-integrator-extension');
 var functions = require('./functions');

var options = { diy: functions };
 // var options = { connectors: { _connectorId: functions } }; // for connectors
 exports.handler = extension.createHandler(options);

Create a zip of the project folder with an archiving utility. It should have package.json , index.js , functions.js , and node_modules in it.

Create a Lambda function on AWS
1. Go to Lambda through Amazon web services dashboard.
2. Click Create a Lambda Function.
3. On the Select blueprint page click Skip.
4. Click Next on the Configure triggers page.
5. Provide a name for the function.
6. Select runtime environment as Node.js 8.10.
7. In the Lambda function code section, select code entry type as Upload a .ZIP file.
8. Click Upload to upload the zip file that was created earlier.
9. Set handler to index.handler.
10. Select Choose an existing role in the Role field.
11. Select the default lambda_basic_execution role in the Existing role field.
12. In the Advanced settings section, click Update memory based on your requirement and choose timeout as 300 seconds.
13. Let the VPC field be set to No VPC.
14. Click on next button.
15. Review the configuration and click Create Function.
Create a stack in integrator.io
1. Log in to integrator.io.
2. Click Options at the top right corner, and select Stacks.
3. Click New Stack.
4. Give an appropriate name for the stack.
5. Select type as AWS Lambda.
6. Update the Access Key Id, Secret Access Key and AWS Region with the IAM User's properties that you saved earlier.
7. Set the function name to the function name of the AWS Lambda function that you previously created.
8. Click Save.

Now, the stack is ready for use and it can be referenced from appropriate exports, imports and connections. The steps above list out the bare minimum setup required to run an AWS Lambda stack. Customize the permissions and other settings according to your own requirements and controls.

Authentication

Bearer tokens

You can generate and access API tokens via Resources > API Tokens, when signed in with Developer mode.

One-time tokens

The integrator.io extension framework supports the use of one-time tokens. The options argument passes one-time tokens to each of your functions and can perform call backs to integrator.io (similarly to bearer tokens). One-time tokens automatically expire after use (or if unused, after 15 minutes of creation). For Integration Apps, one-time tokens can only invoke the resources that belong to the Integration App.

Rate limiting

The integrator.io API is rate limited using a leaky bucket algorithm with a bucket size of 1000 and a fill rate of 300 tokens every 1 second, which approximates to 1,080,000 requests allowed per hour.

Headers

The integrator.io API supports the following custom HTTP headers to facilitate proxying requests directly to a NetSuite RESTlet.

Integrator-NetSuite-ScriptId
Integrator-NetSuite-DeployId