`update` - Record updates
`delete` - Record deletion | | **Actions** | `action` - Action execution
`createApproval` - Approval request created
`approveApproval` - Approval granted
`rejectApproval` - Approval rejected
`markApprovalAsFailed` - Approval failed
`ignoreApprovalWarning` - Warning bypassed
`sendApprovalBackInReview` - Sent back for review | | **Inbox Management** | `startProcessingInboxTask` - Task processing started
`assignUserToInboxTask` - Task assigned
`unassignUserFromInboxTask` - Task unassigned
`cancelInboxTask` - Task cancelled
`autoCancelInboxTask` - Task auto-cancelled | | **Workflows** | `triggerWorkflow` - Workflow initiated
`completeWorkflowStep` - Step completed
`selectWorkflowOption` - Option selected
`reviseWorkflowStep` - Step revised
`resumeWorkflow` - Workflow resumed
`completeWorkflow` - Workflow finished
`abortWorkflow` - Workflow aborted | | **Collaboration** | `createNote` - Note added
`deleteNote` - Note removed
`createMessage` - Message sent | For each action, the system logs the **user, targeted record(s), and timestamp**. Forest tracks and stores these activities **without records' sensitive data** except the ID/primary key.
\$${response.amount / 100} USD has been successfully charged.
Credit card**** **** **** ${response.source.last4}
Expire${response.source.exp_month}/${response.source.exp_year}
Card type${response.source.brand}
Country${response.source.country}
` }); }); }); ... module.exports = router; ```\$${response.amount / 100} USD has been successfully charged.
Credit card**** **** **** ${response.source.last4}
Expire${response.source.exp_month}/${response.source.exp_year}
Card type${response.source.brand}
Country${response.source.country}
` }); }); }); ... module.exports = router; ```**** **** **** #{response.source.last4}
Expire#{response.source.exp_month}/#{response.source.exp_year}
Card type#{response.source.brand}
Country#{response.source.country}
EOF } end end ```$${response.amount / 100} USD has not been charged.
Credit card**** **** **** ${response.source.last4}
ReasonYou can not charge this credit card. The card is marked as blocked
` }); }); }); ... module.exports = router; ```\$${response.amount / 100} USD has not been charged.
Credit card**** **** **** ${record.source.last4}
ReasonYou can not charge this credit card. The card is marked as blocked
` }); }); }); ... module.exports = router; ```Type of your field.
- string:
Boolean,Date,Dateonly,Enum,File,Number,String - array:
\['Enum'],\['Number'],\['String']
Please fill in the customer details first, following this guide
' }, { type: 'Layout', component: 'Row', fields: [fieldByName('firstname'), fieldByName('lastname')] }, { type: 'Layout', component: 'Separator' }, fieldByName('username'), fieldByName('email'), ] }, { type: 'Layout', component: 'Page', elements: [ { type: 'Layout', component: 'HtmlBlock', content: 'You may now enter his address details' }, { type: 'Layout', component: 'Row', fields: [fieldByName('city'), fieldByName('zip code')] }, fieldByName('country'), ] } ] } collection('customers', { actions: [ { name: 'Send invoice', type: 'single', fields: [ { field: 'firstname', type: 'String', isRequired: true, }, { field: 'lastname', type: 'String', isRequired: true, }, { field: 'username', type: 'String', }, { field: 'email', type: 'String', isRequired: true, }, { field: 'country', type: 'Enum', enums: [], }, { field: 'city', type: 'String', hook: 'onCityChange', }, { field: 'zip code', type: 'String', hook: 'onZipCodeChange', }, ], hooks: { load: async ({ fields }) => { return applyLayout(fields); }, change: { onCityChange: async ({ fields }) => { return applyLayout(fields); }, onZipCodeChange: async ({ fields }) => { return applyLayout(fields); }, }, }, }, ], fields: [], segments: [], }); ``` ### Prefill a form with default values Forest allows you to set default values of your form. In this example, we will prefill the form with data coming from the record itself **(1)**, with just a few extra lines of code.${results.origin_addresses[0]}
and
${results.destination_addresses[0]}
Distance${results.rows[0].elements[0].distance.text}
Duration${results.rows[0].elements[0].duration.text}
`, }); }) .catch((e) => console.log(e.response.error)); } ); module.exports = router; ``` # Call a n8n webhook Source: https://docs.forest.app/legacy/javascript-agents/reference-guide/actions/smart-action-examples/call-a-webhook-with-record-ids *** description: >- This example shows how to call a third party webhook/automation tool like n8n, make or zapier… *** # Call a n8n webhook You need to declare the new action with its scope in the `users.js` model ```javascript theme={null} // forest/users.js const Liana = require('forest-express-sequelize'); Liana.collection('users', { actions: [ { name: 'Notify with slack', type: 'single', }, ], }); ``` Then implement the action as needed in the route route action: ```javascript theme={null} // routes/users.js const express = require('express'); const router = express.Router(); const Liana = require('forest-express-sequelize'); const models = require('../models'); const Liana = require('forest-express-sequelize'); const superagent = require('superagent'); router.post( '/actions/notify-with-slack', Liana.ensureAuthenticated, async (request, response) => { const { query, user } = request; const [userId] = await new RecordsGetter( models.user, user, query ).getIdsFromRequest(request); try { await superagent .post('https://user.app.nn.cloud/webhook/123456/abcde/') .send({ userId }); response.send({ success: 'Called webhook' }); } catch (e) { return response .status(400) .send({ error: `Failure calling webhook: ${e.message}` }); } } ); module.exports = router; ``` # Create a record with a multiselect through a many-to-many relationship Source: https://docs.forest.app/legacy/javascript-agents/reference-guide/actions/smart-action-examples/create-a-record-with-a-multiselect-through-a-many-to-many-relationship **Context:** In this case, a card has many expense categories through a many to many relationships, using a join table (card expense categories). We want to be able to create a card, selecting the categories, and creating the card expense categories at the same time. **Implementation:** We will use a [smart action](/legacy/javascript-agents/reference-guide/actions/create-and-manage-smart-actions/overview) form with a hook to retrieve the categories as values for the multi select. Then we implement the creation of cards and expenseCategories in the form. `forest/cards.js` ```jsx theme={null} const { collection } = require('forest-express-sequelize'); const { expenseCategories } = require('../models'); // This file allows you to add to your Forest UI: // - Smart actions:
\{\{this.chart\}\}
```
```javascript theme={null}
import Component from '@glimmer/component';
import {
loadExternalStyle,
loadExternalJavascript,
} from 'client/utils/smart-view-utils';
import { action } from '@ember/object';
import { tracked } from '@glimmer/tracking';
export default class extends Component {
constructor(...args) {
super(...args);
this.loadPlugin();
}
@tracked chart;
@tracked loaded = false;
async loadPlugin() {
await loadExternalJavascript('https://d3js.org/d3.v6.min.js');
this.loaded = true;
this.renderChart();
}
async fetchData() {
const response = await this.lianaServerFetch.fetch(
'/forest/custom-data',
{}
);
const data = await response.json();
return data;
}
@action
async renderChart() {
if (!this.loaded) {
return;
}
const color = 'steelblue';
// Don't comment the lines below if you want to fetch data from your Forest server
// const usersData = await this.fetchData()
// const data = Object.assign(usersData.sort((a, b) => d3.descending(a.points, b.points)), {format: "%", y: "↑ Frequency"})
// To remove if you're using data from your Forest server
const alphabet = await d3.csv(
'https://static.observableusercontent.com/files/09f63bb9ff086fef80717e2ea8c974f918a996d2bfa3d8773d3ae12753942c002d0dfab833d7bee1e0c9cd358cd3578c1cd0f9435595e76901508adc3964bbdc?response-content-disposition=attachment%3Bfilename*%3DUTF-8%27%27alphabet.csv',
function (d) {
return {
name: d.letter,
value: +d.frequency,
};
}
);
const data = Object.assign(
alphabet.sort((a, b) => d3.descending(a.value, b.value)),
{ format: '%', y: '↑ Frequency' }
);
const height = 500;
const width = 800;
const margin = { top: 30, right: 0, bottom: 30, left: 40 };
const x = d3
.scaleBand()
.domain(d3.range(data.length))
.range([margin.left, width - margin.right])
.padding(0.1);
const y = d3
.scaleLinear()
.domain([0, d3.max(data, (d) => d.value)])
.nice()
.range([height - margin.bottom, margin.top]);
const xAxis = (g) =>
g.attr('transform', `translate(0,${height - margin.bottom})`).call(
d3
.axisBottom(x)
.tickFormat((i) => data[i].username)
.tickSizeOuter(0)
);
const yAxis = (g) =>
g
.attr('transform', `translate(${margin.left},0)`)
.call(d3.axisLeft(y).ticks(null, data.format))
.call((g) => g.select('.domain').remove())
.call((g) =>
g
.append('text')
.attr('x', -margin.left)
.attr('y', 10)
.attr('fill', 'currentColor')
.attr('text-anchor', 'start')
.text(data.y)
);
const svg = d3.create('svg').attr('viewBox', [0, 0, width, height]);
svg
.append('g')
.attr('fill', color)
.selectAll('rect')
.data(data)
.join('rect')
.attr('x', (d, i) => x(i))
.attr('y', (d) => y(d.value))
.attr('height', (d) => y(0) - y(d.value))
.attr('width', x.bandwidth());
svg.append('g').call(xAxis);
svg.append('g').call(yAxis);
this.chart = svg.node();
}
}
```
In the above snippet, notice how we import the **D3js** library. Of course, you can choose to use any other library of your choice.
\{\{this.chart\}\}
```
```javascript theme={null}
import Component from '@glimmer/component';
import {
loadExternalStyle,
loadExternalJavascript,
} from 'client/utils/smart-view-utils';
import { action } from '@ember/object';
import { tracked } from '@glimmer/tracking';
export default class extends Component {
constructor(...args) {
super(...args);
this.loadPlugin();
}
@tracked chart;
@tracked loaded = false;
async loadPlugin() {
await loadExternalJavascript('https://d3js.org/d3.v6.min.js');
await loadExternalJavascript('https://unpkg.com/topojson-client@3');
this.loaded = true;
this.renderChart();
}
@action
async renderChart() {
if (!this.loaded) {
return;
}
const height = 610;
const width = 975;
const format = d3.format(',.0f');
const path = d3.geoPath();
// This is the JSON for drawing the contours of the map
// Ref.: https://github.com/d3/d3-fetch/blob/v2.0.0/README.md#json
const us = await d3.json(
'https://static.observableusercontent.com/files/6b1776f5a0a0e76e6428805c0074a8f262e3f34b1b50944da27903e014b409958dc29b03a1c9cc331949d6a2a404c19dfd0d9d36d9c32274e6ffbc07c11350ee?response-content-disposition=attachment%3Bfilename*%3DUTF-8%27%27counties-albers-10m.json'
);
const features = new Map(
topojson.feature(us, us.objects.counties).features.map((d) => [d.id, d])
);
// Population should contain data about the density
const population = await d3.json(
'https://static.observableusercontent.com/files/beb56a2d9534662123fa352ffff2db8472e481776fcc1608ee4adbd532ea9ccf2f1decc004d57adc76735478ee68c0fd18931ba01fc859ee4901deb1bee2ed1b?response-content-disposition=attachment%3Bfilename*%3DUTF-8%27%27population.json'
);
const data = population.slice(1).map(([population, state, county]) => {
const id = state + county;
const feature = features.get(id);
return {
id,
position: feature && path.centroid(feature),
title: feature && feature.properties.name,
value: +population,
};
});
const radius = d3.scaleSqrt([0, d3.max(data, (d) => d.value)], [0, 40]);
const svg = d3.create('svg').attr('viewBox', [0, 0, width, height]);
svg
.append('path')
.datum(topojson.feature(us, us.objects.nation))
.attr('fill', '#ddd')
.attr('d', path);
svg
.append('path')
.datum(topojson.mesh(us, us.objects.states, (a, b) => a !== b))
.attr('fill', 'none')
.attr('stroke', 'white')
.attr('stroke-linejoin', 'round')
.attr('d', path);
const legend = svg
.append('g')
.attr('fill', '#777')
.attr('transform', 'translate(915,608)')
.attr('text-anchor', 'middle')
.style('font', '10px sans-serif')
.selectAll('g')
.data(radius.ticks(4).slice(1))
.join('g');
legend
.append('circle')
.attr('fill', 'none')
.attr('stroke', '#ccc')
.attr('cy', (d) => -radius(d))
.attr('r', radius);
legend
.append('text')
.attr('y', (d) => -2 * radius(d))
.attr('dy', '1.3em')
.text(radius.tickFormat(4, 's'));
svg
.append('g')
.attr('fill', 'brown')
.attr('fill-opacity', 0.5)
.attr('stroke', '#fff')
.attr('stroke-width', 0.5)
.selectAll('circle')
.data(
data
.filter((d) => d.position)
.sort((a, b) => d3.descending(a.value, b.value))
)
.join('circle')
.attr('transform', (d) => `translate(${d.position})`)
.attr('r', (d) => radius(d.value))
.append('title')
.text((d) => `${d.title} ${format(d.value)}`);
this.chart = svg.node();
}
}
```
In the above snippet, notice how we import the **D3js** library. Of course, you can choose to use any other library of your choice.
card number
${company.creditCard.card_number
.match(/.{1,4}/g)
.join(' ')}
card holder
${
company.creditCard.card_holder
? company.creditCard.card_holder
: company.name
}
expires at
${
company.creditCard.expiry_date
}
${fieldName}
${account.right[fieldName]}
`
}
return rightsList
}
}
}],
```
## Second step: Update through a smart action
Then to edit, create a smart action (in the same file) that will open a form with an input for each feature to update (prefilled with the current value)
```jsx theme={null}
actions:[{
name: 'update rights',
type: 'single',
fields: [{
field: 'feature1',
type: 'Boolean',
description: 'insert value to update field',
},{
field: 'feature2',
type: 'Boolean',
description: 'insert value to update field',
}],
values: (context) => {
async function getRights(context){
// wait until you fetch the movie record - IMPORTANT do not forget to include the hasone relationship with the movie characteristics table
let account = await models.accounts.findByPk(context.id, {include:[{model: models.rights}]})
return account.right
}
// Forest will automatically match all of the form fields that have the same name as your movie characteristics fields and prefill with their value
return getRights(context)
}
}],
```
Then define what happens when the form is sent and the route is called. The route needs to be defined in a file `routes/accounts.js`.
You need to get account object and update each field for which a new value has been passed with the relevant value.
0${maxValue}
${progressValue}
`;
},
},
],
});
```
# Generate signed urls to display S3 files in a smart field
Source: https://docs.forest.app/legacy/javascript-agents/reference-guide/smart-fields/smart-field-examples/generate-signed-urls-to-display-s3-files-in-a-smart-field
**Context**: As a user I want to be able to preview files from an S3 bucket thanks to secure signed urls.
${progressValue}
${fieldName}
${user.onboarding_progress[fieldName]}
`;
}
return fieldValueList;
}
},
},
{
field: 'visualizations',
type: ['String'],
reference: 'visualization._id',
},
],
segments: [],
});
```
`style/fields-style.js`
```javascript theme={null}
exports.customFieldsStyles = {
fieldDivStyle: 'margin: 24px 0px; color: #415574',
fieldNameStyle:
'padding: 6px 16px; margin: 12px; background-color:#b5c8d05e; border-radius: 6px',
fieldValueStyle: 'padding: 6px 16px; margin: 12px; border-radius: 6px',
fieldValueStyleRed:
'padding: 6px 12px; background-color:#ff7f7f87; border-radius: 6px',
fieldValueStyleGreen:
'padding: 6px 12px; background-color:#7FFF7F; border-radius: 6px',
};
```
# Sort by smart field
Source: https://docs.forest.app/legacy/javascript-agents/reference-guide/smart-fields/smart-field-examples/sort-by-smart-field
Context: as a user, I want to be able to sort a collection based on a smart field. This example is based on [the one provided in the documentation](https://docs.forestadmin.com/documentation/reference-guide/fields/create-and-manage-smart-fields#creating-a-smart-field) with a simple concatenation of 2 fields existing in the collection.
We have a `customers` collection with a field `firstname` and field `lastname`. We create a smart field `fullname` that is a concatenation of the two fields.
#### **Smart field definition**
In order to make the field sortable, you need to add the `isSortable` attribute.
`forest/customers.js`
```jsx theme={null}
{
field: 'fullname',
type: 'String',
isSortable: true,
get: (customer) => {
return customer.firstname + ' ' + customer.lastname;
},
},
```
#### **Route definition**
At the level of the route, you need to catch the query and redirect the sort field from one that does not exist in the database (`fullname`) to the relevant one (`firstname`)
`routes/customers.js`
```javascript theme={null}
router.get(
'/customers',
permissionMiddlewareCreator.list(),
(request, response, next) => {
// Learn what this route does here: https://docs.forestadmin.com/documentation/v/v6/reference-guide/routes/default-routes#get-a-list-of-records
let sort;
switch (request.query.sort) {
case '-fullname':
sort = '-firstname';
break;
case 'fullname':
sort = 'firstname';
break;
default:
sort = request.query.sort;
}
request.query.sort = sort;
next();
}
);
```
# Sort by smart field that includes value from a belongsTo relationship
Source: https://docs.forest.app/legacy/javascript-agents/reference-guide/smart-fields/smart-field-examples/sort-by-smart-field-that-includes-value-from-a-belongsto-relationship
**Context**: As a user I want to be able to sort records based on a smart field where the smart field includes data from the current record's parent.
**Example**: Here I have a model `orders` that has a belongsTo relationship with the `customers` model.
I have a smart field in the `orders` model called `customer email` that returns the value of the parent customer's email field. I want to sort the orders by the `customer email` smart field.
### Implementation
`forest/orders.js`
```jsx theme={null}
const { collection } = require('forest-express-sequelize');
const models = require('../models');
collection('orders', {
actions: [],
fields: [
{
field: 'customer email',
get: (order) =>
models.customers
.findByPk(order.customer.dataValues.id)
.then((customer) => customer.email),
isSortable: true,
},
],
segments: [],
});
```
`routes/orders.js`
```javascript theme={null}
router.get(
'/orders',
permissionMiddlewareCreator.list(),
(request, response, next) => {
if (request.query.sort.includes('customer email')) {
request.query.sort = request.query.sort.includes('-')
? '-customer.email'
: 'customer.email';
}
next();
}
);
```
# Update point geometry field using a smart field and algolia api
Source: https://docs.forest.app/legacy/javascript-agents/reference-guide/smart-fields/smart-field-examples/update-point-geometry-field-using-a-smart-field-and-algolia-api
|
|
Product details | Images |
|
|---|---|---|---|
|
|
\{\{record.forest-state\}\} |
\{\{#each record.forest-imagesSF as |image|\}\}
|
\{\{#if (eq @recordsCount 0)\}\}
\{\{/unless\}\}
\{\{@collection.pluralizedDisplayName\}\}
There are no items to process.
\{\{/if\}\} \{\{#unless (eq @recordsCount 0)\}\}
\{\{#each @records as |record|\}\}
\{\{/each\}\}
name : \{\{record.forest-firstname\}\} \{\{record.forest-lastname\}\}
email : \{\{record.forest-email\}\}
\{\{moment-format record.forest-createdAt 'LLL'\}\}
\{\{@recordsCount\}\} items to process
Press to approve
Press to reject
Name
\{\{@records.firstObject.forest-firstname\}\} \{\{@records.firstObject.forest-lastname\}\}
Email
\{\{@records.firstObject.forest-email\}\}
Selected date
\{\{#if this.selectedDate\}\}
\{\{this.selectedDate\}\}
\{\{else\}\}
None
\{\{/if\}\}
Duration
Available slots
\{\{#each this.availableSlots as |slot|\}\}
\{\{slot.forest-time\}\}
keyboard_arrow_left
{currentPage} of {numberOfPages}
keyboard_arrow_right
\{\{#each @records as |record|\}\}
\{\{/each\}\}
to : \{\{record.forest-customer.forest-firstname\}\} \{\{record.forest-customer.forest-lastname\}\}
order ID : \{\{record.id\}\}
status : \{\{record.forest-shipping_status\}\}
\{\{moment-format record.forest-created_at 'LLL'\}\}
Order to \{\{this.currentRecord.forest-customer.forest-firstname\}\} \{\{this.currentRecord.forest-customer.forest-lastname\}\}
ID: \{\{this.currentRecord.id\}\}status: \{\{record.forest-shipping_status\}\}
\{\{/each\}\} ``` ### Accessing belongsTo relationships Accessing a `belongsTo` relationship works in exactly the same way as accessing a simple field. Forest triggers automatically an API call to retrieve the data from your Admin API only if it’s necessary. On the `Shipping` Smart View (in the collection named `Order`) defined on our Live Demo example, we’ve displayed the full name of the customer related to an order. ```markup theme={null} \{\{#each @records as |record|\}\}Order to \{\{record.forest-customer.forest-firstname\}\} \{\{record.forest-customer.forest-lastname\}\}
\{\{/each\}\} ``` ### Accessing hasMany relationships Accessing a `hasMany` relationship works in exactly the same way as accessing a simple field.. Forest triggers automatically an API call to retrieve the data from your Admin API only if it’s necessary. ```markup theme={null} \{\{#each @records as |record|\}\} \{\{#each @record.forest-comments as |comment|\}\}\{\{comment.forest-text\}\}
\{\{/each\}\} \{\{/each\}\} ``` ### Refreshing data Trigger the `fetchRecords` action in order to refresh the records on the page. ```markup theme={null} ``` ### Fetching data Trigger an API call to your Admin API in order to fetch records from any collection and with any filters you want. We will use the `store` service for that purpose. Check out the list of all available services from your Smart View. In our Live Demo example, the collection `appointments` has a `Calendar` Smart View. When you click on the previous or next month, the Smart View fetches the new events in the selected month. The result here is set to the property`appointments`. You can access it directly from your template. ```javascript theme={null} import Component from '@glimmer/component'; import { inject as service } from '@ember/service'; import { tracked } from '@glimmer/tracking'; export default class extends Component { @service store; @tracked appointments; async fetchData(startDate, endDate) { const params = { filters: JSON.stringify({ aggregator: 'and', conditions: [{ field: 'start_date', operator: 'greater_than' value: startDate, }, { field: 'start_date', operator: 'less_than' value: endDate, }], }), timezone: 'America/Los_Angeles', 'page[number]': 1, 'page[size]': 50 }; this.appointments = await this.store.query('forest_appointment', params); } // ... }; ``` ```markup theme={null} \{\{#each this.appointments as |appointment|\}\}\{\{appointment.id\}\}
\{\{appointment.forest-name\}\}
\{\{/each\}\} ``` #### Available parameters | Parameter | Type | Description | | ------------- | ------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | filters | Object | A stringified JSON object containing either a filter or an aggregation of several filters. A filter has: `field`, `operator`, `value`. An aggregation has: `aggregator` (and/or), `conditions` (array). Available operators: `less_than`, `greater_than`, `equal`, `after`, `before`, `contains`, `starts_with`, `ends_with`, `not_contains`, `present`, `not_equal`, `blank` | | timezone | String | The timezone string. Example: `America/Los_Angeles`. | | page\[number] | Number | The page number you want to fetch. | | page\[size] | Number | The number of records per page you want to fetch. | ### Deleting records The `deleteRecords` action lets you delete one or multiple records. A pop-up will automatically ask for a confirmation when a user triggers the delete action. ```markup theme={null} \{\{#each @records as |record|\}\}**** **** **** #{response.source.last4}
Expire#{response.source.exp_month}/#{response.source.exp_year}
Card type#{response.source.brand}
Country#{response.source.country}
EOF } end end ```Type of your field.
- string:
Boolean,Date,Dateonly,Enum,File,Number,String - array:
\['Enum'],\['Number'],\['String']
Please fill in the customer details first, following this guide
' }, { type: 'Layout', component: 'Row', fields: [find_field_by_name.call('firstname'), find_field_by_name.call('lastname')] }, { type: 'Layout', component: 'Separator' }, find_field_by_name.call('username'), find_field_by_name.call('email'), ] }, { type: 'Layout', component: 'Page', elements: [ { type: 'Layout', component: 'HtmlBlock', content: 'You may now enter his address details' }, { type: 'Layout', component: 'Row', fields: [find_field_by_name.call('city'), find_field_by_name.call('zip code')] }, find_field_by_name.call('country'), ] } ] end action 'Send invoice', type: 'single', fields: [ { field: 'firstname', type: 'String', is_required: true, }, { field: 'lastname', type: 'String', is_required: true, }, { field: 'username', type: 'String', }, { field: 'email', type: 'String', is_required: true, }, { field: 'country', type: 'Enum', enums: [], }, { field: 'city', type: 'String', hook: 'on_city_change', }, { field: 'zip code', type: 'String', hook: 'on_zip_code_change', }, ], hooks: { load: proc { |context| apply_layout(context[:fields]) }, change: { 'on_city_change' => proc { |context| apply_layout(context[:fields]) }, 'on_zip_code_change' => proc { |context| apply_layout(context[:fields]) }, } } end ``` The resulting action form will be:
\{\{this.chart\}\}
```
```javascript theme={null}
import Component from '@glimmer/component';
import {
loadExternalStyle,
loadExternalJavascript,
} from 'client/utils/smart-view-utils';
import { action } from '@ember/object';
import { tracked } from '@glimmer/tracking';
export default class extends Component {
constructor(...args) {
super(...args);
this.loadPlugin();
}
@tracked chart;
@tracked loaded = false;
async loadPlugin() {
await loadExternalJavascript('https://d3js.org/d3.v6.min.js');
this.loaded = true;
this.renderChart();
}
async fetchData() {
const response = await this.lianaServerFetch.fetch(
'/forest/custom-data',
{}
);
const data = await response.json();
return data;
}
@action
async renderChart() {
if (!this.loaded) {
return;
}
const color = 'steelblue';
// Don't comment the lines below if you want to fetch data from your Forest server
// const usersData = await this.fetchData()
// const data = Object.assign(usersData.sort((a, b) => d3.descending(a.points, b.points)), {format: "%", y: "↑ Frequency"})
// To remove if you're using data from your Forest server
const alphabet = await d3.csv(
'https://static.observableusercontent.com/files/09f63bb9ff086fef80717e2ea8c974f918a996d2bfa3d8773d3ae12753942c002d0dfab833d7bee1e0c9cd358cd3578c1cd0f9435595e76901508adc3964bbdc?response-content-disposition=attachment%3Bfilename*%3DUTF-8%27%27alphabet.csv',
function (d) {
return {
name: d.letter,
value: +d.frequency,
};
}
);
const data = Object.assign(
alphabet.sort((a, b) => d3.descending(a.value, b.value)),
{ format: '%', y: '↑ Frequency' }
);
const height = 500;
const width = 800;
const margin = { top: 30, right: 0, bottom: 30, left: 40 };
const x = d3
.scaleBand()
.domain(d3.range(data.length))
.range([margin.left, width - margin.right])
.padding(0.1);
const y = d3
.scaleLinear()
.domain([0, d3.max(data, (d) => d.value)])
.nice()
.range([height - margin.bottom, margin.top]);
const xAxis = (g) =>
g.attr('transform', `translate(0,${height - margin.bottom})`).call(
d3
.axisBottom(x)
.tickFormat((i) => data[i].username)
.tickSizeOuter(0)
);
const yAxis = (g) =>
g
.attr('transform', `translate(${margin.left},0)`)
.call(d3.axisLeft(y).ticks(null, data.format))
.call((g) => g.select('.domain').remove())
.call((g) =>
g
.append('text')
.attr('x', -margin.left)
.attr('y', 10)
.attr('fill', 'currentColor')
.attr('text-anchor', 'start')
.text(data.y)
);
const svg = d3.create('svg').attr('viewBox', [0, 0, width, height]);
svg
.append('g')
.attr('fill', color)
.selectAll('rect')
.data(data)
.join('rect')
.attr('x', (d, i) => x(i))
.attr('y', (d) => y(d.value))
.attr('height', (d) => y(0) - y(d.value))
.attr('width', x.bandwidth());
svg.append('g').call(xAxis);
svg.append('g').call(yAxis);
this.chart = svg.node();
}
}
```
In the above snippet, notice how we import the **D3js** library. Of course, you can choose to use any other library of your choice.
\{\{this.chart\}\}
```
```javascript theme={null}
import Component from '@glimmer/component';
import {
loadExternalStyle,
loadExternalJavascript,
} from 'client/utils/smart-view-utils';
import { action } from '@ember/object';
import { tracked } from '@glimmer/tracking';
export default class extends Component {
constructor(...args) {
super(...args);
this.loadPlugin();
}
@tracked chart;
@tracked loaded = false;
async loadPlugin() {
await loadExternalJavascript('https://d3js.org/d3.v6.min.js');
await loadExternalJavascript('https://unpkg.com/topojson-client@3');
this.loaded = true;
this.renderChart();
}
@action
async renderChart() {
if (!this.loaded) {
return;
}
const height = 610;
const width = 975;
const format = d3.format(',.0f');
const path = d3.geoPath();
// This is the JSON for drawing the contours of the map
// Ref.: https://github.com/d3/d3-fetch/blob/v2.0.0/README.md#json
const us = await d3.json(
'https://static.observableusercontent.com/files/6b1776f5a0a0e76e6428805c0074a8f262e3f34b1b50944da27903e014b409958dc29b03a1c9cc331949d6a2a404c19dfd0d9d36d9c32274e6ffbc07c11350ee?response-content-disposition=attachment%3Bfilename*%3DUTF-8%27%27counties-albers-10m.json'
);
const features = new Map(
topojson.feature(us, us.objects.counties).features.map((d) => [d.id, d])
);
// Population should contain data about the density
const population = await d3.json(
'https://static.observableusercontent.com/files/beb56a2d9534662123fa352ffff2db8472e481776fcc1608ee4adbd532ea9ccf2f1decc004d57adc76735478ee68c0fd18931ba01fc859ee4901deb1bee2ed1b?response-content-disposition=attachment%3Bfilename*%3DUTF-8%27%27population.json'
);
const data = population.slice(1).map(([population, state, county]) => {
const id = state + county;
const feature = features.get(id);
return {
id,
position: feature && path.centroid(feature),
title: feature && feature.properties.name,
value: +population,
};
});
const radius = d3.scaleSqrt([0, d3.max(data, (d) => d.value)], [0, 40]);
const svg = d3.create('svg').attr('viewBox', [0, 0, width, height]);
svg
.append('path')
.datum(topojson.feature(us, us.objects.nation))
.attr('fill', '#ddd')
.attr('d', path);
svg
.append('path')
.datum(topojson.mesh(us, us.objects.states, (a, b) => a !== b))
.attr('fill', 'none')
.attr('stroke', 'white')
.attr('stroke-linejoin', 'round')
.attr('d', path);
const legend = svg
.append('g')
.attr('fill', '#777')
.attr('transform', 'translate(915,608)')
.attr('text-anchor', 'middle')
.style('font', '10px sans-serif')
.selectAll('g')
.data(radius.ticks(4).slice(1))
.join('g');
legend
.append('circle')
.attr('fill', 'none')
.attr('stroke', '#ccc')
.attr('cy', (d) => -radius(d))
.attr('r', radius);
legend
.append('text')
.attr('y', (d) => -2 * radius(d))
.attr('dy', '1.3em')
.text(radius.tickFormat(4, 's'));
svg
.append('g')
.attr('fill', 'brown')
.attr('fill-opacity', 0.5)
.attr('stroke', '#fff')
.attr('stroke-width', 0.5)
.selectAll('circle')
.data(
data
.filter((d) => d.position)
.sort((a, b) => d3.descending(a.value, b.value))
)
.join('circle')
.attr('transform', (d) => `translate(${d.position})`)
.attr('r', (d) => radius(d.value))
.append('title')
.text((d) => `${d.title} ${format(d.value)}`);
this.chart = svg.node();
}
}
```
In the above snippet, notice how we import the **D3js** library. Of course, you can choose to use any other library of your choice.
|
|
Product details | Images |
|
|---|---|---|---|
|
|
\{\{record.forest-state\}\} |
\{\{#each record.forest-imagesSF as |image|\}\}
|
\{\{#if (eq @recordsCount 0)\}\}
\{\{/unless\}\}
\{\{@collection.pluralizedDisplayName\}\}
There are no items to process.
\{\{/if\}\} \{\{#unless (eq @recordsCount 0)\}\}
\{\{#each @records as |record|\}\}
\{\{/each\}\}
name : \{\{record.forest-firstname\}\} \{\{record.forest-lastname\}\}
email : \{\{record.forest-email\}\}
\{\{moment-format record.forest-createdAt 'LLL'\}\}
\{\{@recordsCount\}\} items to process
Press to approve
Press to reject
Name
\{\{@records.firstObject.forest-firstname\}\} \{\{@records.firstObject.forest-lastname\}\}
Email
\{\{@records.firstObject.forest-email\}\}
Selected date
\{\{#if this.selectedDate\}\}
\{\{this.selectedDate\}\}
\{\{else\}\}
None
\{\{/if\}\}
Duration
Available slots
\{\{#each this.availableSlots as |slot|\}\}
\{\{slot.forest-time\}\}
keyboard_arrow_left
{currentPage} of {numberOfPages}
keyboard_arrow_right
\{\{#each @records as |record|\}\}
\{\{/each\}\}
to : \{\{record.forest-customer.forest-firstname\}\} \{\{record.forest-customer.forest-lastname\}\}
order ID : \{\{record.id\}\}
status : \{\{record.forest-shipping_status\}\}
\{\{moment-format record.forest-created_at 'LLL'\}\}
Order to \{\{this.currentRecord.forest-customer.forest-firstname\}\} \{\{this.currentRecord.forest-customer.forest-lastname\}\}
ID: \{\{this.currentRecord.id\}\}status: \{\{record.forest-shipping_status\}\}
\{\{/each\}\} ``` ### Accessing belongsTo relationships Accessing a `belongsTo` relationship works in exactly the same way as accessing a simple field. Forest triggers automatically an API call to retrieve the data from your Admin API only if it’s necessary. On the `Shipping` Smart View (in the collection named `Order`) defined on our Live Demo example, we’ve displayed the full name of the customer related to an order. ```markup theme={null} \{\{#each @records as |record|\}\}Order to \{\{record.forest-customer.forest-firstname\}\} \{\{record.forest-customer.forest-lastname\}\}
\{\{/each\}\} ``` ### Accessing hasMany relationships Accessing a `hasMany` relationship works in exactly the same way as accessing a simple field.. Forest triggers automatically an API call to retrieve the data from your Admin API only if it’s necessary. ```markup theme={null} \{\{#each @records as |record|\}\} \{\{#each @record.forest-comments as |comment|\}\}\{\{comment.forest-text\}\}
\{\{/each\}\} \{\{/each\}\} ``` ### Refreshing data Trigger the `fetchRecords` action in order to refresh the records on the page. ```markup theme={null} ``` ### Fetching data Trigger an API call to your Admin API in order to fetch records from any collection and with any filters you want. We will use the `store` service for that purpose. Check out the list of all available services from your Smart View. In our Live Demo example, the collection `appointments` has a `Calendar` Smart View. When you click on the previous or next month, the Smart View fetches the new events in the selected month. The result here is set to the property`appointments`. You can access it directly from your template. ```javascript theme={null} import Component from '@glimmer/component'; import { inject as service } from '@ember/service'; import { tracked } from '@glimmer/tracking'; export default class extends Component { @service store; @tracked appointments; async fetchData(startDate, endDate) { const params = { filters: JSON.stringify({ aggregator: 'and', conditions: [{ field: 'start_date', operator: 'greater_than' value: startDate, }, { field: 'start_date', operator: 'less_than' value: endDate, }], }), timezone: 'America/Los_Angeles', 'page[number]': 1, 'page[size]': 50 }; this.appointments = await this.store.query('forest_appointment', params); } // ... }; ``` ```markup theme={null} \{\{#each this.appointments as |appointment|\}\}\{\{appointment.id\}\}
\{\{appointment.forest-name\}\}
\{\{/each\}\} ``` #### Available parameters | Parameter | Type | Description | | ------------- | ------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | filters | Object | A stringified JSON object containing either a filter or an aggregation of several filters. A filter has: `field`, `operator`, `value`. An aggregation has: `aggregator` (and/or), `conditions` (array). Available operators: `less_than`, `greater_than`, `equal`, `after`, `before`, `contains`, `starts_with`, `ends_with`, `not_contains`, `present`, `not_equal`, `blank` | | timezone | String | The timezone string. Example: `America/Los_Angeles`. | | page\[number] | Number | The page number you want to fetch. | | page\[size] | Number | The number of records per page you want to fetch. | ### Deleting records The `deleteRecords` action lets you delete one or multiple records. A pop-up will automatically ask for a confirmation when a user triggers the delete action. ```markup theme={null} \{\{#each @records as |record|\}\}Status: {{record.forest-shipping_status}}
{{/each}} ``` ### Accessing belongsTo relationships Accessing a `belongsTo` relationship works the same as a field. Forest automatically fetches the related data via API when needed: ```handlebars theme={null} {{#each @records as |record|}}Order to {{record.forest-customer.forest-firstname}} {{record.forest-customer.forest-lastname}}
{{/each}} ``` ### Accessing hasMany relationships Same behavior applies for `hasMany` relationships: ```handlebars theme={null} {{#each @records as |record|}} {{#each record.forest-comments as |comment|}}{{comment.forest-text}}
{{/each}} {{/each}} ``` ### Refreshing records Call `@fetchRecords` to reload the current page of records: ```handlebars theme={null} ``` ### Fetching records with custom filters Use the `store` service to query any collection with custom filters. In the example below, a calendar view fetches appointments within a date range: ```js title="component.js" theme={null} import Component from '@glimmer/component'; import { inject as service } from '@ember/service'; import { tracked } from '@glimmer/tracking'; export default class extends Component { @service store; @tracked appointments; async fetchData(startDate, endDate) { const params = { filters: JSON.stringify({ aggregator: 'And', conditions: [ { field: 'start_date', operator: 'GreaterThan', value: startDate }, { field: 'start_date', operator: 'LessThan', value: endDate }, ], }), timezone: 'America/Los_Angeles', 'page[number]': 1, 'page[size]': 50, }; this.appointments = await this.store.query('forest_appointment', params); } } ``` ```handlebars title="template.hbs" theme={null} {{#each this.appointments as |appointment|}}{{appointment.id}}
{{appointment.forest-name}}
{{/each}} ``` #### Query parameters | Parameter | Type | Description | | -------------- | ------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `filters` | Object | A stringified JSON object. A single filter uses `{ field, operator, value }`. An aggregation uses `{ aggregator: "and"/"or", conditions: [...] }`. Operators: `less_than`, `greater_than`, `equal`, `after`, `before`, `contains`, `starts_with`, `ends_with`, `not_contains`, `present`, `not_equal`, `blank` | | `timezone` | String | Timezone string, e.g. `America/Los_Angeles` | | `page[number]` | Number | Page number to fetch | | `page[size]` | Number | Number of records per page | ## Deleting records The `deleteRecords` action deletes one or multiple records. A confirmation dialog is shown automatically. ```handlebars title="template.hbs" theme={null} {{#each @records as |record|}}
{{#each @records as |record|}}
{{/each}}
to: {{record.forest-customer.forest-firstname}} {{record.forest-customer.forest-lastname}}
order ID: {{record.id}}
status: {{record.forest-shipping_status}}
Order to {{this.currentRecord.forest-customer.forest-firstname}} {{this.currentRecord.forest-customer.forest-lastname}}
ID: {{this.currentRecord.id}}{{this.chart}}
```
## Example: cohort retention chart
A retention table with shaded cells, also using D3.js.
Name: ${customer.firstName} ${customer.lastName}
Email: ${customer.email}
Company: ${customer.company.name}
`, }); }, }); ``` ```ruby Ruby theme={null} collection.add_action( 'Display customer info', BaseAction.new(scope: ActionScope::SINGLE) do |context, result_builder| # Get specific fields customer = context.get_record([ 'firstName', 'lastName', 'email', 'company:name' # Relation field ]) result_builder.success( 'Customer info', html: "Name: #{customer['firstName']} #{customer['lastName']}
Email: #{customer['email']}
Company: #{customer['company']['name']}
" ) end ) ```Success: ${results.success.length}
Failed: ${results.failed.length}
Failed users: ${results.failed.join(', ')}
`, }); } }, }); ``` ```ruby Ruby theme={null} collection.add_action( 'Send notifications', BaseAction.new(scope: ActionScope::BULK) do |context, result_builder| users = context.get_records(['id', 'email', 'name']) results = { success: [], failed: [] } users.each do |user| begin send_notification(user['email'], user['name']) results[:success] << user['name'] rescue => error results[:failed] << user['name'] end end if results[:failed].empty? result_builder.success("Sent #{results[:success].length} notifications") else result_builder.error( 'Some notifications failed', html: "Success: #{results[:success].length}
Failed: #{results[:failed].length}
Failed users: #{results[:failed].join(', ')}
" ) end end ) ```
Hi ${ctx.formValues.firstName} ${ctx.formValues.lastName},
here you can put all the HTML you want.
`,
}
```
```ruby Ruby theme={null}
{
type: FieldType::LAYOUT,
component: 'HtmlBlock',
content: ->(context) {
"Hi #{context.form_values['firstName']}
"
},
}
```
Charged $${Amount} to ${customer.email}
Transaction ID: ${charge.id}
`, }); } catch (error) { return resultBuilder.error(`Charge failed: ${error.message}`); } }, }); ``` ```ruby Ruby theme={null} collection.add_action( 'Charge Credit Card', BaseAction.new( scope: ActionScope::SINGLE, form: [ { type: FieldType::NUMBER, label: 'Amount', is_required: true }, { type: FieldType::STRING, label: 'Description', is_required: true } ] ) do |context, result_builder| customer = context.get_record(['stripeId', 'email']) amount = context.form_values['Amount'] description = context.form_values['Description'] begin charge = Stripe::Charge.create( amount: (amount * 100).to_i, currency: 'usd', customer: customer['stripeId'], description: description ) result_builder.success( 'Charge successful', html: "Charged $#{amount} to #{customer['email']}
Transaction ID: #{charge.id}
" ) rescue => error result_builder.error("Charge failed: #{error.message}") end end ) ```Transaction #${transactionId} created successfully
Amount: $${amount}
`, invalidated: ['transactions', 'balance'], }); ``` ```ruby Ruby theme={null} result_builder.success( 'Transaction created', html: "Transaction ##{transaction_id} created successfully
Amount: $#{amount}
", invalidated: ['transactions', 'balance'] ) ```$${amount} USD has been successfully charged.
Credit card**** **** **** ${last4}
Transaction ID${transactionId}
`, }); ``` ```ruby Ruby theme={null} result_builder.success( message: 'Charge successful', options: { html: "$#{amount} USD has been successfully charged.
Credit card**** **** **** #{last4}
Transaction ID#{transaction_id}
" } ) ```$${amount} USD has not been charged.
ReasonThe credit card is marked as blocked.
`, }); ``` ```ruby Ruby theme={null} result_builder.error( 'Charge failed', html: "$#{amount} USD has not been charged.
ReasonThe credit card is marked as blocked.
" ) ```Summary
Processed ${result.count} items
-
${result.items.map(i => `
- ${i} `).join('')}
Error: ${result.error}
`, }); } } ``` ```ruby Ruby theme={null} execute: ->(context, result_builder) { result = perform_complex_operation if result[:success] result_builder.success( 'Operation completed', html: "Summary
Processed #{result[:count]} items
- #{result[:items].map { |i| "
- #{i} " }.join}
Error: #{result[:error]}
" ) end } ```Hi {{ record.name }},
', requesterEmailDefault: record => String(record.email ?? ''), senderEmail: 'support@acme.com', priorityOverride: 'high', ticketIdField: 'last_zendesk_ticket_id', }); ``` | Option | Type | Description | | ----------------------- | ------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `client` | `ZendeskClient` | The Zendesk client instance. **Required when `subdomain` / `email` / `apiToken` are not provided.** | | `subdomain` | `string` | Zendesk subdomain. **Required when `client` is not provided** (the plugin then builds a client from these credentials). | | `email` | `string` | Email associated with the API token. Required alongside `subdomain` and `apiToken`. | | `apiToken` | `string` | Zendesk API token. Required alongside `subdomain` and `email`. | | `actionName` | `string` | Overrides the action label. Defaults to `'Create ticket and notify'`. | | `defaultSubject` | `string \| (record) => string` | Default value for the "Subject" field. As a string, supports `{{ record.Hi {{record.name}},
', requester_email_default: ->(record) { record['email'] }, sender_email: 'support@acme.com', priority_override: 'high', ticket_id_field: 'last_zendesk_ticket_id' ) end ``` | Option | Description | | ------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `datasource` | **Required.** The `ForestAdminDatasourceZendesk::Datasource` instance. | | `action_name` | Overrides the action label. Defaults to `'Create ticket and notify'`. | | `default_subject` | String used to pre-fill the "Subject" field. Supports `{{record.Hi {{ record.first_name }}, your refund has been processed.
', }, { title: 'Shipping delay', content: 'Hi {{ record.first_name }}, we apologise for the delay shipping order #{{ record.order_id }}.
', }, ], }); ```Hi {{record.first_name}}, your refund has been processed.
' }, { title: 'Shipping delay', content: 'Hi {{record.first_name}}, we apologise for the delay shipping order #{{record.order_id}}.
' } ] ) ```(coordinates)"] -- "pending steps" --> R["Forest Runtime
(your infrastructure)"] R -- "data & actions" --> A["Your Forest agent"] --> DB[("Your business
database")] R -. "state (DATABASE_URL)" .-> P[("Forest Runtime's
Postgres")] R -- "outcomes only, never records" --> O ``` ## Prerequisites * A recent **Forest Admin agent** — the minimum version depends on how you run Forest Runtime (below). * A **PostgreSQL** database for production: Forest Runtime persists its run state there. A database-free mode exists for testing only. ## Running Forest Runtime Run Forest Runtime one of two ways: * **[Embedded in your Node.js agent](#embedded-in-the-nodejs-agent)** — one line in your agent, nothing separate to deploy. The simplest option. * **[Standalone](#standalone-docker-or-cli)** — a separate process (Docker or CLI), to scale it independently of your agent or to use it with a Ruby agent. ### Embedded in the Node.js agent Requirements: * **`@forestadmin/agent`** — embedded mode arrived in **1.84.0**, but the options shown below (`schema`, `ai`, `encryptionKey`, the tuning knobs) landed in later releases, so use a **recent** version. * **Node.js ≥ 22.12.0** — required by the executor package. * **The executor package**, installed at the **exact version your agent pins**. It's an *optional peer dependency* the agent loads dynamically at runtime, so `tsc` won't flag it when it's missing — but `agent.start()` throws *"The embedded workflow executor requires the `@forestadmin/workflow-executor` package"*. The pin is exact (a `^` range conflicts), so install that specific version — find it in your lockfile or with `npm info @forestadmin/agent@
useUnsafeActionEndpoint | boolean | No | Drop the positional index from Smart Action routes.Default `false`. | **Example:** ```typescript theme={null} const agent = createAgent({ authSecret: process.env.FOREST_AUTH_SECRET, envSecret: process.env.FOREST_ENV_SECRET, isProduction: process.env.NODE_ENV === 'production', }); ```
It removes the positional index (`/_actions/{collection}/{slug}` instead of `/_actions/{collection}/{index}/{slug}`), which can make two action names collide on the same route.
When enabled, the agent refuses to start if two actions on the same collection resolve to the same slug.
Needs to be verified
", "createdAt": "2024-02-20T10:35:54.685Z", "user": { "object": "user", "email": "alice@somewhere.com", "id": 1, "username": "alice" } }, { "object": "note-message", "content": "Ok
", "createdAt": "2024-02-20T11:15:32.461Z", "user": { "object": "user", "email": "bob@somewhere.com", "id": 1, "username": "bob" } } ] } ] } ``` ### Response fields | Field | Type | Description | | -------------------- | ----------------- | ------------------------------------------------------------------------------------------------------------------------- | | `hasMore` | boolean | Whether more notes are available after this set. | | `data[].id` | integer | The note id. | | `data[].title` | string | The note title. | | `data[].recordId` | string | The id of the record the note is attached to. | | `data[].createdAt` | string (ISO 8601) | When the note was created. | | `data[].updatedAt` | string (ISO 8601) | When the note (or one of its messages) was last updated. | | `data[].archivedAt` | string (ISO 8601) | When the note was archived, if applicable. | | `data[].user` | object | The user who created the note (`id`, `username`, `email`). | | `data[].environment` | object | The environment the note is attached to. | | `data[].team` | object | The team the note is attached to. | | `data[].collection` | object | The collection the note is attached to. Notes created on collections deleted before 2024-06-11 may be missing this field. | | `data[].messages` | array | Messages within the note thread. Each has `content` (HTML), `createdAt`, and `user`. | ### Errors | Status | Meaning | | ------ | --------------------------------------------------------------------------------------------------------- | | `429` | Too many requests. The response includes a `Retry-After` header indicating the number of seconds to wait. | | `4XX` | Client error. Response body contains `code` and `message`. | | `5XX` | Server error. Response body contains `code` and `message`. | # Trigger a workflow via webhook Source: https://docs.forest.app/reference/api/endpoints/trigger-workflow-webhook Start a workflow run on a specific record from an external system, over authenticated HTTP. ## Trigger a workflow run Starts a run of a workflow on a specific record. External systems call the workflow's webhook URL to trigger it the same way an operator would from the interface, but over authenticated HTTP. ``` POST