112 lines
3.6 KiB
Plaintext
112 lines
3.6 KiB
Plaintext
---
|
|
title: "Polling Trigger"
|
|
description: "Periodically call endpoints to check for changes"
|
|
---
|
|
|
|
|
|
|
|
The way polling triggers usually work is as follows:
|
|
|
|
**On Enable:**
|
|
Store the last timestamp or most recent item id using the context store property.
|
|
|
|
**Run:**
|
|
This method runs every **5 minutes**, fetches the endpoint between a certain timestamp or traverses until it finds the last item id, and returns the new items as an array.
|
|
|
|
**Testing:**
|
|
You can implement a test function which should return some of the most recent items. It's recommended to limit this to five.
|
|
|
|
**Examples:**
|
|
- [New Record Airtable](https://github.com/activepieces/activepieces/blob/main/packages/pieces/community/airtable/src/lib/trigger/new-record.trigger.ts)
|
|
- [New Updated Item Salesforce](https://github.com/activepieces/activepieces/blob/main/packages/pieces/community/salesforce/src/lib/trigger/new-updated-record.ts)
|
|
|
|
# Polling library
|
|
|
|
There multiple strategy to implement polling triggers, and we have created a library to help you with that.
|
|
|
|
## Strategies
|
|
|
|
**Timebased:**
|
|
|
|
This strategy fetches new items using a timestamp. You need to implement the items method, which should return the most recent items.
|
|
The library will detect new items based on the timestamp.
|
|
|
|
The polling object's generic type consists of the props value and the object type.
|
|
|
|
```typescript
|
|
const polling: Polling<{ authentication: OAuth2PropertyValue, object: string }> = {
|
|
strategy: DedupeStrategy.TIMEBASED,
|
|
items: async ({ propsValue, lastFetchEpochMS }) => {
|
|
// Todo implement the logic to fetch the items
|
|
const items = [ {id: 1, created_date: '2021-01-01T00:00:00Z'}, {id: 2, created_date: '2021-01-01T00:00:00Z'}];
|
|
return items.map((item) => ({
|
|
epochMilliSeconds: dayjs(item.created_date).valueOf(),
|
|
data: item,
|
|
}));
|
|
}
|
|
}
|
|
```
|
|
|
|
**Last ID Strategy:**
|
|
|
|
This strategy fetches new items based on the last item ID. To use this strategy, you need to implement the items method, which should return the most recent items.
|
|
The library will detect new items after the last item ID.
|
|
|
|
The polling object's generic type consists of the props value and the object type
|
|
|
|
```typescript
|
|
const polling: Polling<{ authentication: AuthProps}> = {
|
|
strategy: DedupeStrategy.LAST_ITEM,
|
|
items: async ({ propsValue }) => {
|
|
// Implement the logic to fetch the items
|
|
const items = [{ id: 1 }, { id: 2 }];
|
|
return items.map((item) => ({
|
|
id: item.id,
|
|
data: item,
|
|
}));
|
|
}
|
|
}
|
|
```
|
|
|
|
## Trigger Implementation
|
|
|
|
After implementing the polling object, you can use the polling helper to implement the trigger.
|
|
|
|
```typescript
|
|
export const newTicketInView = createTrigger({
|
|
name: 'new_ticket_in_view',
|
|
displayName: 'New ticket in view',
|
|
description: 'Triggers when a new ticket is created in a view',
|
|
type: TriggerStrategy.POLLING,
|
|
props: {
|
|
authentication: Property.SecretText({
|
|
displayName: 'Authentication',
|
|
description: markdownProperty,
|
|
required: true,
|
|
}),
|
|
},
|
|
sampleData: {},
|
|
onEnable: async (context) => {
|
|
await pollingHelper.onEnable(polling, {
|
|
store: context.store,
|
|
propsValue: context.propsValue,
|
|
auth: context.auth
|
|
})
|
|
},
|
|
onDisable: async (context) => {
|
|
await pollingHelper.onDisable(polling, {
|
|
store: context.store,
|
|
propsValue: context.propsValue,
|
|
auth: context.auth
|
|
|
|
})
|
|
},
|
|
run: async (context) => {
|
|
return await pollingHelper.poll(polling, context);
|
|
},
|
|
test: async (context) => {
|
|
return await pollingHelper.test(polling, context);
|
|
}
|
|
});
|
|
```
|