Add a value to an object with the given key

If you would like to insert a key/value pair into a nested portion of the object, use the **Insert Path** input to specify where it should be added.
For example, if your object reads:

```json
{
  "employee": {
    "id": "123",
    "hired": "2022-03-05T00:08:00",
    "contact": {
      "phone": "6024441234"
    }
  }
}
```

You can add an email address to `contact` by specifying `"email"` for **Key**, `"example@company.com"` for **Value**, and `employee.contact` for **Insert Path**.
The result will be:

```json
{
  "employee": {
    "id": "123",
    "hired": "2022-03-05T00:08:00",
    "contact": {
      "phone": "6024441234",
      "email": "example@company.com"
    }
  }
}
```


This action applies the filter function (if given) first, and then applies the aggregate function to the filtered list.
See the [Filter](#filter) action for examples of how to use the filter function.


Chunk the list into lists of the specified number of elements

This version of the action is being deprecated. Please replace action with Create Object.

Acme Contracting

Concatenate two lists together into a single list

Count the number of occurrences of element in list

Creates a new object from provided key/value pairs

Maps the values from two different collections and returns a key/value list where the 'key' is the value of the Key Mappings input and the 'value' is the value of the Value Mappings input

This action applies a NodeJS [filter function](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter) to an array of data.
The filter function should use arrow notation, and include an input (an element) and a function that evaluates to `true` or `false`.
Its return value is an array of elements that evaluated to `true`.

#### Simple Filter

For example, if you have an array, `["exuberant", "spray", "limit", "elite", "destruction", "present"]`, and you would like words with a length greater than 6, your filter function could read:

```typescript
(word) => word.length > 6;
```

The result would be `["exuberant", "destruction", "present"]` - all words whose length is greater than 6.

#### Filters on Objects

If your array is comprised of objects, you can apply a filter using each object's properties.

For example, suppose you have an array of objects like this:

```json
[
  {
    "name": "Widget",
    "cost": 80,
    "available": true
  },
  {
    "name": "Whatsits",
    "cost": 90,
    "available": false
  },
  {
    "name": "Whoseits",
    "cost": 120,
    "available": true
  },
  {
    "name": "Whysits",
    "cost": 75,
    "available": true
  }
]
```

If you want to find items whose cost is less than 100 that have `true` for availability, you can write a filter function like this:

```javascript
(item) => item.cost < 100 && item.available;
```

The return value of this example would be an array of two objects that passed the filter:

```javascript
[
  {
    name: "Widget",
    cost: 80,
    available: true,
  },
  {
    name: "Whysits",
    cost: 75,
    available: true,
  },
];
```


Widget

Thingy

Whatsit

Flatten an array of arrays into a single array

This action applies a NodeJS [map function](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map) to an array of data.

It also has an optional [filter function](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter) - see the [Filter](#filter) action for examples.
The action applies the filter function (if present), and then the map function to your array.

#### Simple Map Function

If you have an array of integers that represent pennies, like `[1234, 567, 890]`, and you would like to turn all values in dollar amounts, you could divide all values using a map function like this:

```javascript
(value) => value / 100;
```

The result of the step would be an array that reads `[12.34, 5.67, 8.9]`

#### Mapping on Objects

If you have an array of objects, you can reference the object's fields in your map function.
Suppose you have an array of "people" objects, and you'd like to concatenate their names and order in the list.

Your data might look like this:

```json
[
  { "first": "Bob", "last": "Smith", "middle": "Billy" },
  { "first": "John", "last": "Doe" },
  { "first": "Lisa", "last": "Nguyen", "middle": "Sue" }
]
```

Your map function could look like this:

```javascript
(person, index) => {
  if (person.middle) {
    return `${index} - ${person.last}, ${person.first} ${person.middle[0]}.`;
  } else {
    return `${index} - ${person.last}, ${person.first}`;
  }
};
```

The result of the step would be an array of strings:

```json
["0 - Smith, Bob B.", "1 - Doe, John", "2 - Nguyen, Lisa S."]
```

### Providing additional context to the map function

You can provide additional context to the map function by using the `context` input.
`context` can be anything - a string, number or object.

For example, suppose your data is an array of objects:

```json
[
  { "product": "Item 1", "price": 10 },
  { "product": "Item 2", "price": 11 },
  { "product": "Item 3", "price": 12 },
  { "product": "Item 4", "price": 9 },
  { "product": "Item 5", "price": 15 },
  { "product": "Item 6", "price": 16 }
]
```

If you provide the context as an object:

```json
{ "minPrice": 10, "prepend": "My" }
```

And your filter function looks like this:

```javascript
(item, index, context) => {
  return item.price > context.minPrice;
};
```

And your map function looks like this:

```javascript
(item, index, context) => {
  return `${context.prepend} ${item.product}`;
};
```

Then your result would be the names of all items with a price greater than 10, with `"My "` prepended to the name:

```json
["My Item 2", "My Item 3", "My Item 5", "My Item 6"]
```


Ensures that payloads are processed in order across executions according to an ordering specified by a payload attribute. Returns the largest possible set of ordered payloads on the Process branch, and otherwise follows the Skip branch and returns the current item.

The **Process In Order** action allows you to send several requests to an instance out of order, and helps to ensure that data runs through your integration in order.
Requests with data payloads are collected, and when an ordered set of requests have been received this action processes the requests in the order you specify.

In order to use this action, you will need to know how many total items you are sending ahead of time.

**Example**: suppose we are updating an inventory system with three updates, and order is important.
We want to process _widgets_ first, then _gadgets_, and finally _whatsits_.
We know that we have three items to import, and due to limitations of our third-party system we can't send them all at once.
We're not confident that they'll arrive to Prismatic in any particular order, so we'll use this action to help.

<Screenshot
  filename="components/collection-tools/processInOrder-integration.png"
  alt="Collection Tools - Process in Order flow in Prismatic integration designer"
/>

We'll come up with a unique "Collection ID", and begin sending our data in any order:

```bash "Data gets sent in any order"
$ curl 'https://hooks.prismatic.io/trigger/EXAMPLE==' \
    --header "Content-Type: application/json" \
    --data '{"item": "whatsits", "index": 2}' \
    --header 'collectionid: abc-123' \
    --header 'collectionlength: 3'

$ curl 'https://hooks.prismatic.io/trigger/EXAMPLE==' \
    --header "Content-Type: application/json" \
    --data '{"item": "widgets", "index": 0}' \
    --header 'collectionid: abc-123' \
    --header 'collectionlength: 3'

$ curl 'https://hooks.prismatic.io/trigger/EXAMPLE==' \
    --header "Content-Type: application/json" \
    --data '{"item": "gadgets", "index": 1}' \
    --header 'collectionid: abc-123' \
    --header 'collectionlength: 3'
```

The first time that our integration is invoked, the `{"item": "whatsits", "index": 2}` payload will be stored for future processing, since items with index `0` and `1` have not yet been processed.

The second time that our integration is invoked, the `{"item": "widgets", "index": 0}` payload will be processed immediately, since it has index `0`, but then our loop will stop since an item with index `1` has not yet been received.

The third time our integration is invoked, the `{"item": "gadgets", "index": 1}` will be processed right away, since it has index `1` and an item with index `0` has already been processed.
The `{"item": "whatsits", "index": 2}` payload will also be pulled from storage and processed since it is next in line to be processed.

At this point all items will have been processed.

_Note_: Items must be zero-indexed.


FooBar Consulting

Remove all occurrences of an element from a list

Select an item by index from a list of items, supports nested lists

Sort elements using a JavaScript comparison function

Take first number of elements from a list

Validate a JSON input against a given schema, returning errors if not JSON input is not valid.

Validate an XML input against a given XSD schema, returning errors if XML is not valid.

The collection tools component contains actions that let you perform common tasks on collections of data (objects and arrays).
You can do things like concatenate objects, filter items of lists (arrays), map functions on items, and more.


Action Name	Action Description
Combine Collection (Deprecated)	This version of the action is being deprecated. Please replace action with Create Object.
Field Value Mapping	Maps the values from two different collections and returns a key/value list where the 'key' is the value of the Key Mappings input and the 'value' is the value of the Value Mappings input
Process In Order	Ensures that payloads are processed in order across executions according to an ordering specified by a payload attribute. Returns the largest possible set of ordered payloads on the Process branch, and otherwise follows the Skip branch and returns the current item.
Take First	Take first number of elements from a list
Take Last	Take last number of elements from a list
First	Get first element from a list
Last	Get last element from a list
Count	Count the number of occurrences of element in list
Chunks	Chunk the list into lists of the specified number of elements
Length	Count the number of elements in list
De-duplicate	De-duplicate the elements of the list
Append	Append element to the end of the list
Remove	Remove all occurrences of an element from a list
Concatenate	Concatenate two lists together into a single list
Object to Key Value Pair List	Convert an Object to a Key Value List
Create List	Create a new list with the given inputs
Flatten	Flatten an array of arrays into a single array
Select Item From List by Index	Select an item by index from a list of items, supports nested lists
Create Object	Creates a new object from provided key/value pairs
Key Value Pair List to Object	Convert a Key Value list to an Object
Add Key/Value to Object	Add a value to an object with the given key
Aggregate	Apply aggregate function to list
Map	Transform a list and its elements
Filter	Filter elements of a list
Sort	Sort elements using a JavaScript comparison function
Validate JSON Schema	Validate a JSON input against a given schema, returning errors if not JSON input is not valid.
Validate XML Schema	Validate an XML input against a given XSD schema, returning errors if XML is not valid.

Collection Tools Component

Integrate with customers’ other SaaS apps, fast

About the Collection Tools Component

Actions

Ready to get started?