Module Reference

A categorized list of all the modules currently available to be used when building a connector inside the connector builder.

Control

Assign If

Overview

Assign a value based on the output of an expression.

Input Fields

  • left-operand: The first operand in the expression.
  • operator: The operator to compare two values in an expression.
  • right-operand: The second operand in the expression.
  • valueIfFalse: The value that will be assigned as this module's "output", when the expression evaluates to false.
  • valueIfTrue: The value that will be assigned as this module's "output", when the expression evaluates to true.

Output Fields

  • output: The value returned by the expression. For example, if the expression evaluates to "true" and the "valueIfTrue" equals 5, then referring to [moduleID].output for this module will reference the value "5".

Continue If

Continue the function if...

Input Fields

  • left-operand: The first operand in the expression.
  • operator: The operator to compare two values in an expression.
  • otherwise.message: The message that will be set as this module's output value if the given expression evaluates to "false".
  • right-operand: The second operand in the expression.

Output Fields

  • message: The message that was sent when the expression was evaluated to "false". To use this message in the rest of your method, use "[thisModuleID].output".

Let

Declare or rename variables in the local scope.

Input Fields

  • *User-Determined*:  The keys placed into "input" represent the new variables to assign values to. If "Foo" is set as a key in this module, with value "Baz", you may use "{{[moduleIDHere].Foo}}" throughout the rest of the method to refer to the value "Baz". You may assign as many variables inside "inputs" as you need.

Output Fields

  • *Empty*: The keys placed into "input" will be implicitly mirrored as output for this module. You may define items here, but it is not necessary. If there are keys in this output that are not found in the input, your Connector will not compile.

Examples

{
   "brick": "control.let",
   "id": "[idHere]",
   "inputs": {
     "[desiredVariableNameHere]" : "[desiredValueHere]"
   },
   "outputs": {}
 }

Spawn

Spawn a child flo and wait for the resulting output.

Input Fields

  • flo: The FLO that you would like to call. Set _value to the name of the FLO that you woluld like to call, with proper casing and spelling. You must specify the _type as "flo", or else it will fail to compile.

Output Fields

  • output: The result of the last step of the FLO called by this module. For example, if you call "methodName", and "methodName" ends with an obstruct.construct module, the output of this module will be the object constructed in "methodName".

Throw If

Throw an error if...

Input Fields

  • left-operand: The first operand in the expression.
  • message: The message that will be shown in the console, as the error message
  • operator: The operator to compare two values in an expression.
  • right-operand: The second operand in the expression.

Output Fields

  • *Empty* : There is no output for this module. Note, because this module has no output, you cannot end a method with this module.

Object

Construct

Constructs an object with values stored at input keys.

Inputs

  • *User-Defined*: This input object will contain the schema that you want your constructed object to be set to. See example for more information.

Outputs

  • output: The constructed object.

Example

This will be one of your most-used modules in Forge. This module will help you shape data into the forms you need- which is often used to render data into the format needed to display your Connector in the Designer. In this example, you'll see the desired object shape and how one would declare this shape in the Object.Construct module.

{
  "brick": "object.construct",
  "id": "12345",
  "inputs": {
    "Example Top Level Object" : {
        "InnerObject" : {
            "Key" : "{{reference to a value here}}""
        }
    }
  },
  "outputs": {
    "output": {
      "_type": "object",
      "_array": false
    }
  }

Resulting object:

"Example Top Level Object" : {
    "InnerObject" : {
        "Key" : "resulting value"
    }
}

Filter

Filter empty values from an object and return the new object.

Inputs

  • object: The object that you would like to filter keys with empty values out of.

Outputs

  • output: The object that no longer has keys with empty values.

Get

Reads the value stored in an object at a given path, with embedded paths delimited by a dot.

Inputs

  • object: The object that you would like to grab a value from.
  • path: The path that you would like to grab the value from within the given object.

Outputs

  • output: The value at the given path within the given object.

Pick

Build a new object by picking select values from another object.

Inputs

  • object: The object that you would like to pick objects from.

Outputs

  • *User-Defined*: The items you would like to pick out from the given object. You must define which items you would like to have be output from this function. See example for details.

Example

To use this module, you need to choose the object that you would like to pick from first. After this, choose the keys you would like to put into a new object by defining them in this module's "outputs" section. You must define the appropriate type and collection state of each key, in accordance with that key's type/state.

{
  "brick": "object.pick",
  "id": "IDHere",
  "inputs": {
    "object": {
      "_type": "object",
      "_array": false,
      "_value": "{{object.name}}"
    }
  },
  "outputs": {
    "pathName1" : {
      "_type" : "<insert the type of this path's value here>",
      "_array" : "<insert true if this path's value is a collection, false otherwise>"
    },
    "pathName2" : {
      "_type" : "<insert the type of this path's value here>",
      "_array" : "<insert true if this path's value is a collection, false otherwise>"
    }
  }
}

Process

Builds a new object by performing a FLO over each key inside of a given object.

Inputs

  • object: The object you would like to process
  • flo: The FLO that will handle the processing of your object
  • concurrency: The concurrency at which your subFLO will operate at over the items inside the provided object.

Outputs

  • output: The resulting, processed object.

Example

Here's an example method that will perform an operation on both the key and value for each item inside of an object. In this case, the end goal is to go over each key and increment its corresponding value, and to append that new value onto the key's name.

If our starting list is:

{
 "key": 1,
 "key2": 2,
 "key3": 3
}


Then the ending list will be:


{
 "key2" : 2,
 "key3" : 3,
 "key4" : 4
}

Defining the actual process brick is fairly straightforward:

{
  "brick": "object.process",
  "id": "ryEhp",
  "inputs": {
    "object": {
      "_type": "object",
      "_array": false,
      "_value": {
        "key": 1,
        "key2": 2,
        "key3": 3
      }
    },
    "flo": {
      "_type": "flo",
      "_array": false,
      "_value": "addOne"
    },
    "concurrency": {
      "_type": "number",
      "_array": false,
      "_value": 1
    }
  },
  "outputs": {
    "output": {
      "_type": "object",
      "_array": false
    }
  }
}

Setting up your processing subFLO (in this case, called "addOne") is key to getting this to work properly.

The method that will iterate over this list contains two modules, add and construct, which accomplishes the actual goal of our method. These work the same as any metadata method with a variant (like List.map), with the exception how we declare the variant.

There are two variant values in this case, the key and the value. In map, we're used to using just one value called key, but with Object.process, we need to be able access both the key and the value. To enable this, you now declare both in a variant array, that contains both key and value. You can then refer to these values within the core array for that metadata method.

{
  "name": "addOne",
  "description": "No description provided.",
  "kind": "metadata",
  "variant": [
    {
      "_key": "key",
      "_type": "string",
      "_defaultValue": ""
    },
    {
      "_key": "value",
      "_type": "number",
      "_defaultValue": 0
    }
  ],
  "zebricks": [
    {
      "brick": "math.add",
      "id": "add",
      "inputs": {
        "a": {
          "_type": "number",
          "_array": false,
          "_value": "{{value}}"
        },
        "b": {
          "_type": "number",
          "_array": false,
          "_value": 1
        }
      },
      "outputs": {
        "output": {
          "_type": "number",
          "_array": false
        }
      }
    },
    {
      "brick": "object.construct",
      "id": "r1Yc0",
      "inputs": {
        "key": "{{key}}",
        "value": "{{add.output}}"
      },
      "outputs": {
        "output": {
          "_type": "object",
          "_array": false
        }
      }
    }
  ]
}

If you wanted to do this inline, you would instead declare "item" as an array in the parent module, like so:


  "item": [
    "key",
    "value"
  ]

XML

Build

Convert an object to an XML string.

Inputs

  • doctype: The desired doctype of your XML document, may be left blank.
  • encoding: This value determines the character encoding used in this XML document. Defaults to UTF-8
  • indent: This value determines how an indent is defined in your XML document, may be left blank.
  • newline: This value determines how a newline is defined in your XML document, may be left blank.
  • object: The object you would like to interpret into XML.
  • pretty: This value determines whether or not you want this XML document to rendered in "pretty" style.
  • rootName: The root name of your XML document, may be left blank.
  • standalone: Determines whether or not this XML document has an internal DTD. If false, the XML document has an external DTD.
  • version: This value determines what version of XML standard this will use. Defaults to 1.0

Outputs

  • xml: The processed and returned XML object.

List

Construct

Constructs an array with values stored at numbered keys.

Input Fields

  • *User-Defined*: Here, you will set up the structure of your list, by creating a schema with indices and values. The keys for each item must be the index that you want it placed in within your new list. The highest number integer specified in your schema will be the latest populated index, with all previous values set to null, unless otherwise specified.   

Output Fields

  • list: The list that was created as the result of this module. Note- the output defaults to an array of object, if you would like to change the type, change the "_type" key.

Examples

Here's an example that illustrates how your keys and values are set up in a List.Construct. In this case, the keys are intentionally out of order, to illustrate that list order is determined by the key used. Also, this illustrates that undefined indices within the constructed list are automatically set to null.

{
  "brick": "list.construct",
  "id": "BJ5s2",
  "inputs": {
    "2": {
      "_type": "object",
      "_array": false,
      "_value": {
        "item" : "Thing2"
      }
    },
    "0" : {
      "item" : "Thing0"
    }
  },
  "outputs": {
    "list": {
      "_type": "object",
      "_array": true
    }
  }
}

Resulting list:
"list": [
    {
      "item": "Thing0"
    },
    null,
    {
      "item": "Thing2"
    }
  ]

Filter

Filter a collection by applying a flo to each element. Each flo invocation that returns false will remove the associated element from the output array.

Input Fields

  • concurrency: The concurrency rate that the filtering occurs with
  • flo: The flo that will serve to filter the specified list. This flo must end with a true or false value. All items that run through this flo and result as "false" are removed from the list.
  • list: The list that will have the specified filtering operations performed on it.

Output Fields

  • list: The resulting, filtered list

Filter By 

Filter a collection by comparing the value for each element at a path to a provided value. The comparison is dictated by an input operation: one of ==, !=, >, <, >=, or <=.

Input Fields

  • comparison: The value that will be used to compare against each item in the provided list.
  • list: The list that will have the specified filtering operations performed on it.
  • operator: The operator that will be used to compare the given path of each item in the provided list against a comparison value.
  • path: The path inside of each item in the list that will be used to filter against.

Output Fields

  • list: The resulting, filtered list

Find

Find an element in a collection by applying a flo to each one in series and returning the first element for which the associated flo returns true.

Input Fields

  • flo: The flo that will serve to search through the specified list. This flo must end with a true or false value. The first item to return as true will be set as the output for this module.
  • list: The list that will be searched.

Output Fields

  • item: The first item in the provided list that returns from the subFLO as "true"

Find By

Find an element in a collection by comparing the value for each element at a path to a provided value. The comparison is dictated by an input operation: one of ==, !=, >, <, >=, or <=.

Input Fields

  • comparison: The value that will be used to compare against each item in the provided list.
  • list: The list that will have the specified filtering operations performed on it.
  • operator: The operator that will be used to compare the given path of each item in the provided list against a comparison value.
  • path: The path inside of each item in the list that will be used to filter against.

Output Fields

  • item: The first value inside the provided list that results as "true" with the given tests.

Flatten 

Create a recursively flattened array from an array of possibly embedded arrays.

Input Fields

  • lists: An array of lists you would like to flatten into one list. You may place any number of lists in this array, either through a comma-separated list of Mustache references or through specifically enumerated lists.

Output Fields

  • list: The resulting, flattened list.

Join

Concatenate the elements of an array into a string, combined by a delimiting string.

Input Fields

  • delimiter: The string you would like to use in-between each item from your list in the newly composed string.
  • list: The list of items that you would like to join together as a string.

Output Fields

  • string: The resulting string, that contains each item of your provided list, separated by the delimiter string input.

Map

Map a collection to another collection by processing each element with a flo and storing the resulting output. The output array will have the result of each inner flo in the same order as the input array.

Input Fields

  • concurrency: The concurrency of the map operation.
  • flo: The FLO that will process each item in your given list. You may set "_value" to either another method's name (See example 1), or you can place a module inline for simple tasks (See example 2). 
  • list: The list of items that will be iterated over and changed with the provided FLO.

Output Fields

  • new list: The list of items after they have been processed by the given FLO.

Example 1

This is an example of a List.Map module that uses a separate metadata method to perform an operation on each item in a list. This technique should be used when the operation you want to perform requires more than a couple of modules to complete. If the operation would only be one or two modules, you might consider using in-line modules. See the other List.Map for more details if this is the case.

Using List.Map with a separate metadata method for processing requires you to add a "variant" flag in the metadata method you will be using. Information about this can be found in the Forge Documentation under "Metadata Methods: Metadata Method Classes". To be able to refer to each item in the list, you must set a name for each item. To do so, select the name of your metadata method on the left-hand menu. Then place the "variant" object as a top-level item. 

{ 
   "name": "[metadataMethodName]", 
   "kind": "metadata", 
   "variant": { 
     "_type": "object", 
     "_key": "itemName", 
     "_array": false
   }, 
   "zebricks": [ 
     { 
      //modules you create will go here 
     } 
   ] 
 }

Inside the "variant" object, set the "_key" object to the name you would like to use. After this has been set, you may refer to the item throughout that metadata method by using a Mustache reference with the name, like so: {{itemName}}. Depending on what each item in the list you are iterating over is, you may have to change _type and _array to match accordingly.

Example 2

If you are performing a relatively simple set of operations on each item inside your list, in-line (anonymous) FLOs is a good way to go. This style allows you to forego creating helper function, for a more "trackable" set of logic in one place. To use this, set "_value" of your "flo" input to be an object or array of objects, if you're doing more than one module operation in your anonymous child flo. Each one of those objects will be a direct copy and paste of a normal connector module. As you can see in the following example, the "flo" contains a single "object.construct" module inside of it- and will therefore perform an object construct on each item in the original list.

Additionally, in-line FLOs still allow you to still reference each item in the list, without having to define the "variant" object. With in-line FLOs, all you have to do is set the top-level "item" field to be the name that you would like to call each item in your list. In the below example, each item in my list would be referred to using "{{itemName}}" inside my in-line FLO.

{
   "brick": "list.map",
   "id": "ID",
   "item": "itemName",
   "inputs": {
     "list": {
       "_availableTypes": [
         "*"
       ],
       "_type": "object",
       "_array": true,
       "_value": "{{listNameHere}}"
     },
     "flo": {
       "_type": "flo",
       "_array": false,
       "_value": {
         "brick": "object.construct",
         "id": "ID",
         "inputs": {
           "NewFormat" : "{{itemName.path}}"
         },
         "outputs": {
           "output": {
             "_type": "object",
             "_array": false
           }
         }
       }
     },
     "concurrency": {
       "_type": "number",
       "_array": false,
       "_value": 0
     }
   },
   "outputs": {
     "new list": {
       "_type": "object",
       "_array": true
     }
   }
 }

 

Map Filter

Filter a collection by applying a flo to each element. Each flo invokation that returns false will remove the associated element from the output array. However, instead of returning the filtered input collection this will return the filtered output collection. This is analagous to a map followed by a filter.

Inputs

  • concurrency: The concurrency of this filter operation.
  • flo: The flo that will test each item in the provided list. If an item in this list does not pass the test in this flo (returns "false"), that item will be omitted from the new list that is returned from this module. The subFLO selected for this input must return a boolean value.
  • list: The list that will be filtered.

Outputs

  • new list: The new list that contains only the items from the original list that passed the filter test.

Reduce

Reduce a collection to an object by applying a flo to each element in series. This is based on the traditional 'reduce' operation in a functional programming language. Should not be used to reduce a list into a smaller list. 

Inputs

  • flo: The subFLO that will handle the reduction process. You must add a "memo" object to your subFLO. See following example or the "Metadata Method: Metadata Method Classes" section in the documentation for more information.
  • list: The list that will be reduced.
  • memo: The object that the list will be reduced into. To refer to the memo object in the subFLO, you must add a "memo" object inside of your metadata method. See following example or the "Metadata Method: Metadata Method Classes" section in the documentation for more information

Outputs

  • item: The object (or other data type) that the list has been reduced into.

Example 1:

This example will use the List.Reduce module to take in a list, and then reduces that list's items into a single object. In this particular case we're going through a list where each item has a field called "in". This field determines where that item should be stored. Here's that list:

 [ 
 { 
    "name": "item1",
    "in": "A",
    "field" : "value1"
 },
 { 
    "name": "item2",
    "in": "B",
    "field" : "value2"
 }, 
 { 
   "name": "item3",
   "in": "B",
   "field" : "value3"
 }
]

And here's what the final result will be:

  {
     "A" : [ 
        { 
          "name": "item1",
          "field" : "value1",
          "in" : "A" 
        } 
      ],
     "B" : [
        {
          "name": "item2",
          "field" : "value2",
          "in" : "B"
        },
        { 
           "name": "item3",
           "field" : "value3",
           "in" : "B" 
        }
     ]
}

Seeing both of these, we know a couple of things before we even get started:

  •  We will need our memo to start off as an empty object, that we then build on as we iterate through the list
  • While iterating over our original list, we will then create or update the lists inside of our memo object ("A" and "B")

The first thing we will need to define is the List.Reduce module that will kick off this operation. In this example, it will look like:

{
    "brick": "list.reduce",
    "id": "REDUCE",
    "inputs": {
        "list": {
                "_availableTypes": [
                        "*"
                ],
                "_type": "object",
                "_array": true,
                "_value": <list reference here>
        },
        "memo": {
             "_availableTypes": [
                  "*"
             ],
             "_type": "object",
             "_array": false,
             "_value": {}
         },
        "flo": {
               "_type": "flo",
               "_array": false,
               "_value": "reduceToObject"
          }
    },
    "outputs": {
            "item": {
                "_type": "object",
                "_array": false
          }
     }
}

Next, we will need to add two top-level keys to the child FLO we will be using to process each item in the original list (reduceToObject). One will be the 'memo', that we will build on as we iterate through our list. The other is the 'variant' that will represent the item we are currently processing as we iterate through our list. We'll define them like this:

 "variant": { 
      "_type": "object",
      "_key": "item",
      "_array": false
  }, 
  "memo": {
     "_type": "object",
     "_array": false
  }

Now, onto the actual implementation. A couple of notes:

  •  We will be able to refer to and change the memo by using "{{memo}}". At the end of each run of this child FLO, we will want to make sure that we've altered the memo, or else the List.Reduce function will just return an empty object.
  •  I've named my 'variant' 'item', as seen in the "_key" field above.

Here is the inner child FLO, with all bricks underneath:

1) Start by checking to see where this item needs to be placed in our memo object with an object.get that reads the item's "in" field.

{ 
   "brick": "object.get", 
   "id": "IN", 
   "inputs": {
      "object": { 
          "_type": "object", 
          "_array": false, 
          "_value": "{{item}}" 
       }, 
      "path": { 
          "_type": "string", 
          "_array": false, 
          "_value": "in" 
      } 
    }, 
    "outputs": { 
       "output": { 
           "_type": "string", 
           "_array": false 
         } 
     } 
}

2)  Then we grab the memo and see what's stored at the item's "in" value. For example, if the item has "in" set to "A", we need to grab the "A" key from the memo.

{ 
   "brick": "object.get", 
   "id": "GRAB LIST", 
   "inputs": { 
       "object": { 
       "_type": "object", 
       "_array": false, 
       "_value": "{{memo}}" 
    }, 
    "path": { 
         "_type": "string", 
         "_array": false, 
         "_value": <item's "in" value> 
     } 
  }, 
  "outputs": { 
      "output": { 
          "_type": "object", 
          "_array": true 
       } 
   } 
}

3) We then need to take whatever list was stored at the "in" key for our memo, and add our 'item' to it

{ 
    "brick": "list.push", 
    "id": "UPDATED", 
    "inputs": { 
       "item": { 
           "_availableTypes": [ "*" ], 
           "_type": "object",
           "_array": false, 
           "_value": "{{item}}"
        }, 
        "list": { 
           "_availableTypes": [ "*" ],
           "_type": "object", 
           "_array": true, 
           "_value": "{{GRAB LIST.output}}"
         } 
     }, 
     "outputs": { 
         "list": { 
             "_type": "object", 
             "_array": true 
          } 
       }
 }

4) Finally, we just need to update the whole memo item with our updated inner list

{ 
    "brick": "object.set", 
    "id": "NEW MEMO VAL", 
    "inputs": { 
         "object": { 
            "_type": "object", 
            "_array": false, 
            "_value": "{{memo}}" 
         }, 
        "path": { 
             "_type": "string", 
             "_array": false, 
             "_value": "{{item.in}}" 
         }, 
         "value": { 
            "_availableTypes": [ "*" ], 
            "_type": "object", 
            "_array": true, 
            "_value": "{{UPDATED.list}}" 
         } 
      }, 
      "outputs": { 
           "output": { 
              "_type": "object", 
             "_array": false 
            } 
       } 
}

After each iteration, we will now have an updated memo! This completed object is then available as the output from the List.Reduce module.

Sort By

Sort a collection by the value stored at a given path in each element.

Inputs

  • list: The list that will be sorted
  • path: The path that will be used to determine sorting order

Outputs

  • sorted list: The sorted list.

Zip

Takes two arrays of equal length, A and B, and combines them into an array where index i is an array of the form [A[i], B[i]].

Inputs

  • list1: A list to zip together. All items in this list will precede an item in "list2". This list must be the same length as "list2"
  • list2: A list to zip together. All items in this list will follow an item in "list1". This list must be the same length as "list1"

Outputs

  • list: The resulting list. This list will be in this form: [list1[i], list2[i]]

JSON

Parse

Parses a string into a JSON object with an unspecified schema.

Input Fields

  • string: The string you would like to parse into a JSON object.

Output Fields

  • output: The generated JSON object

Render

Renders an object or string of mustache references into an object or string composed of those references.

Input Fields

  • schema: The user-defined schema of the JSON object returned from this module.

Output Fields

  • output: The JSON object rendered by this module.

Example

{
  "brick": "json.render",
  "id": "HkIbD",
  "inputs": {
    "schema": {
      "_type": "object",
      "_array": false,
      "_defaultValue": null,
      "_value": {
        "Character": {
          "Name": "{{allInfo.body.name}}"
         }
       }
  }                                                                                                                                                    },
  "outputs": {
    "output": {
      "_type": "object",
      "_array": false,
      "_defaultValue": null,
      "_value": {}
    }
  }
}

HTTP

Call

Performs an HTTP request, returning the result of this request and the response headers. On input, takes a required URL input and optional auth, header, body, and query inputs. Each optional input can either be modeled by a singular object-typed input or by multiple keys with the appropriate group attribute. On output, returns an object with two keys, headers and output. The output key contains the response body, and the headers key contains the response header. More detailed information can be accessed about these by using multiple keys with the appropriate grouping.

Input Fields

  • (Optional) body: The body being passed with the HTTP request.
  • (Optional) headers: The headers being passed with the HTTP request. If Basic Authentication is defined in the Authentication section of your Connector, you do not need to set an "Authorization" header, as it will be automatically sent for you. See "Authorization" in the documentation for more information. Can only be an object, or a reference to an object (with Mustache).
  • (Optional) query: The query passed with the HTTP request. Can be a string or an object.
  • filterEmpty: A boolean value determining whether or not to filter out all "null" and "undefined" values from your HTTP request.
  • method: The method of the HTTP request. Can be "GET", "PUT", "POST", "DELETE".
  • url: The url for the HTTP request.

Output Fields

  • rawBody: The response, in raw form, from the service.
  • statusCode: The status code response from the service.

Delete

Performs an HTTP DELETE request, returning the result of this request and the response headers. On input, takes a required URL input and optional auth, header, body, and query inputs. Each optional input can either be modeled by a singular object-typed input or by multiple keys with the appropriate group attribute. On output, returns an object with two keys, headers and output. The output key contains the response body, and the headers key contains the response header. More detailed information can be accessed about these by using multiple keys with the appropriate grouping.

Input Fields

  • (Optional) body: The body being passed with the HTTP request.
  • (Optional) headers: The headers being passed with the HTTP request. If Basic Authentication is defined in the Authentication section of your Connector, you do not need to set an "Authorization" header, as it will be automatically sent for you. See "Authorization" in the documentation for more information. Can only be an object, or a reference to an object (with Mustache).
  • (Optional) query: The query passed with the HTTP request. Can be a string or an object.
  • filterEmpty: A boolean value determining whether or not to filter out all "null" and "undefined" values from your HTTP request.
  • url: The url for the HTTP request.

Output Fields

  • body: The body of the HTTP response.
  • statusCode: The status code response from the service.

Get

Performs an HTTP GET request, returning the result of this request and the response headers. On input, takes a required URL input and optional auth, header, body, and query inputs. Each optional input can either be modeled by a singular object-typed input or by multiple keys with the appropriate group attribute. On output, returns an object with two keys, headers and output. The output key contains the response body, and the headers key contains the response header. More detailed information can be accessed about these by using multiple keys with the appropriate grouping.

Input Fields

  • (Optional) body: The body being passed with the HTTP request.
  • (Optional) headers: The headers being passed with the HTTP request. If Basic Authentication is defined in the Authentication section of your Connector, you do not need to set an "Authorization" header, as it will be automatically sent for you. See "Authorization" in the documentation for more information. Can only be an object, or a reference to an object (with Mustache).
  • (Optional) query: The query passed with the HTTP request. Can be a string or an object.
  • filterEmpty: A boolean value determining whether or not to filter out all "null" and "undefined" values from your HTTP request.
  • url: The url for the HTTP request.

Output Fields

  • body: The body of the HTTP response.
  • statusCode: The status code response from the service.

Post

Performs an HTTP POST request, returning the result of this request and the response headers. On input, takes a required URL input and optional auth, header, body, and query inputs. Each optional input can either be modeled by a singular object-typed input or by multiple keys with the appropriate group attribute. On output, returns an object with two keys, headers and output. The output key contains the response body, and the headers key contains the response header. More detailed information can be accessed about these by using multiple keys with the appropriate grouping.

Input Fields

  • (Optional) body: The body being passed with the HTTP request.
  • (Optional) headers: The headers being passed with the HTTP request. If Basic Authentication is defined in the Authentication section of your Connector, you do not need to set an "Authorization" header, as it will be automatically sent for you. See "Authorization" in the documentation for more information. Can only be an object, or a reference to an object (with Mustache).
  • (Optional) query: The query passed with the HTTP request. Can be a string or an object.
  • filterEmpty: A boolean value determining whether or not to filter out all "null" and "undefined" values from your HTTP request.
  • url: The url for the HTTP request.

Output Fields

  • body: The body of the HTTP response.
  • statusCode: The status code response from the service.

Put

Performs an HTTP PUT request, returning the result of this request and the response headers. On input, takes a required URL input and optional auth, header, body, and query inputs. Each optional input can either be modeled by a singular object-typed input or by multiple keys with the appropriate group attribute. On output, returns an object with two keys, headers and output. The output key contains the response body, and the headers key contains the response header. More detailed information can be accessed about these by using multiple keys with the appropriate grouping.

Input Fields

  • (Optional) body: The body being passed with the HTTP request.
  • (Optional) headers: The headers being passed with the HTTP request. If Basic Authentication is defined in the Authentication section of your Connector, you do not need to set an "Authorization" header, as it will be automatically sent for you. See "Authorization" in the documentation for more information. Can only be an object, or a reference to an object (with Mustache).
  • (Optional) query: The query passed with the HTTP request. Can be a string or an object.
  • filterEmpty: A boolean value determining whether or not to filter out all "null" and "undefined" values from your HTTP request.
  • url: The url for the HTTP request.

Output Fields

  • body: The body of the HTTP response.
  • statusCode: The status code response from the service.

Date

Generic

Formats a date into the format specified by an input object and input timezone. Returns an object.

Input Fields

  • format: The format that you would like to parse the string into. Takes format in the following ways:
    • YYYY (4 or 2 digit year, 2016)
    • YY (2 digit year, 16)
    • Y (Year with any number of digits and sign, -25)
    • Q  (Quarter of year, 1 ... 4)
    • M or MM (Month number, 1 ... 12)
    • MMM (Shortened month name, Jan)
    • MMMM (Full month name, January)
    • D or DD (Day of month, 25)
    • Do (Day of month with ordinal, 25th)
    • DDD or DDDD (Day of year, 1 ... 365)
    • X (Unix timestamp)
    • x (Unix ms timestamp)
    • w or ww (Week of the year)
    • e (Day of the week)
    • ddd (Shortened day name, Mon)
    • dddd (Full day name, Monday)
    • H or HH (24 hour time)
    • h or hh (12 hour time)
    • a or A (Am or pm)
    • m or mm (Minutes)
    • s or ss (Seconds)
    • S or SS (fractional seconds)
    • Z or ZZ (Offset from UTC, +12:00)
  • start: The date you would like to parse into an object
  • zone: The timezone you would like to format your date into. Uses the "time zone identifier" format. For example, "America/Los_Angeles".

Output Fields

  • day: The day of the month.
  • full: The given date, fully represented. Ex- October 6th, 2016 XX:XX:X.XXX
  • hour: The given hour.
  • millisecond: The given number of milliseconds.
  • minute: The minute of the given date object
  • month: The month.
  • second: The given second (with milliseconds truncated)
  • time: The given time, like HH:MM:s.SS
  • year: The given year

Now

Returns the current time.

Input Fields

  • *Empty*: There are no inputs for this module.

Output Fields

  • date: The current date.
  • day: The current day of the month.
  • full: The current date, fully represented. Ex- October 6th, 2016 XX:XX:X.XXX
  • hour: The current hour.
  • iso: The current date in ISO format.
  • millisecond: The current number of milliseconds.
  • minute: The current minute.
  • month: The current month.
  • second: The current second (with milliseconds truncated)
  • time: The current time, like HH:MM:s.SS
  • year: The current year.

Format

Formats a date into the format specified by an input string and input timezone.

Input Fields

  • format: The format that you would like to parse the string into. Takes format in the following ways:
    • YYYY (4 or 2 digit year, 2016)
    • YY (2 digit year, 16)
    • Y (Year with any number of digits and sign, -25)
    • Q  (Quarter of year, 1 ... 4)
    • M or MM (Month number, 1 ... 12)
    • MMM (Shortened month name, Jan)
    • MMMM (Full month name, January)
    • D or DD (Day of month, 25)
    • Do (Day of month with ordinal, 25th)
    • DDD or DDDD (Day of year, 1 ... 365)
    • X (Unix timestamp)
    • x (Unix ms timestamp)
    • w or ww (Week of the year)
    • e (Day of the week)
    • ddd (Shortened day name, Mon)
    • dddd (Full day name, Monday)
    • H or HH (24 hour time)
    • h or hh (12 hour time)
    • a or A (Am or pm)
    • m or mm (Minutes)
    • s or ss (Seconds)
    • S or SS (fractional seconds)
    • Z or ZZ (Offset from UTC, +12:00)
  • start: The date you would like to parse into a string
  • zone: The timezone you would like to format your date into. Uses the "time zone identifier" format. For example, "America/Los_Angeles".

Output Fields

  • output: The newly formatted string of the given date.